Survey II Assignment

Candela Gómez Blanco, Irene García-Espantaleón Artal, Diego Paroli, Bradley McKenzie
2025-03-13

Loading libraries

Loading data

Survey data

data_raw <- read_dta("data/ZA7575.dta")

Country-level data sets

This is to join various country-level dataset together:

# building a df with country names and codes for the EU-28
codelist <- countrycode::codelist |> 
  select(country.name.en, iso.name.en, un.name.en, cow.name, ecb, eurostat, iso2c, iso3c, eu28) |> 
  filter(!is.na(eu28)) 

GDP per capita

This is GDP per capita, PPP (constant 2021 international $). Retrieved from the World Bank (https://data.worldbank.org/indicator/NY.GDP.PCAP.PP.KD) for the year 2019.

gdp_data <- read_csv("data/gdp_pc_ppp_2021.csv", skip = 4, show_col_types = FALSE)

head(gdp_data)
# A tibble: 6 × 69
  `Country Name`      `Country Code` `Indicator Name` `Indicator Code`
  <chr>               <chr>          <chr>            <chr>           
1 Aruba               ABW            GDP per capita,… NY.GDP.PCAP.PP.…
2 Africa Eastern and… AFE            GDP per capita,… NY.GDP.PCAP.PP.…
3 Afghanistan         AFG            GDP per capita,… NY.GDP.PCAP.PP.…
4 Africa Western and… AFW            GDP per capita,… NY.GDP.PCAP.PP.…
5 Angola              AGO            GDP per capita,… NY.GDP.PCAP.PP.…
6 Albania             ALB            GDP per capita,… NY.GDP.PCAP.PP.…
# ℹ 65 more variables: `1960` <lgl>, `1961` <lgl>, `1962` <lgl>,
#   `1963` <lgl>, `1964` <lgl>, `1965` <lgl>, `1966` <lgl>,
#   `1967` <lgl>, `1968` <lgl>, `1969` <lgl>, `1970` <lgl>,
#   `1971` <lgl>, `1972` <lgl>, `1973` <lgl>, `1974` <lgl>,
#   `1975` <lgl>, `1976` <lgl>, `1977` <lgl>, `1978` <lgl>,
#   `1979` <lgl>, `1980` <lgl>, `1981` <lgl>, `1982` <lgl>,
#   `1983` <lgl>, `1984` <lgl>, `1985` <lgl>, `1986` <lgl>, …
gdp_data <- gdp_data |> 
  select(`Country Name`, `Country Code`, `2019`)


gdp_data <- gdp_data |> 
  rename(country_name = `Country Name`,
         country_code = `Country Code`,
         gdp_pc_ppp = `2019`)

gdp_data <- gdp_data |> 
inner_join(select(codelist, iso3c), by = c("country_code" = "iso3c"))

str(gdp_data)
tibble [28 × 3] (S3: tbl_df/tbl/data.frame)
 $ country_name: chr [1:28] "Austria" "Belgium" "Bulgaria" "Cyprus" ...
 $ country_code: chr [1:28] "AUT" "BEL" "BGR" "CYP" ...
 $ gdp_pc_ppp  : num [1:28] 64630 60452 27673 46157 47720 ...

We now have 28 observations including the UK.

Rural population - to be deleted??????

Retrieved from the World Bank (https://data.worldbank.org/indicator/SP.RUR.TOTL.ZS).

Data on the % of population living in rural areas over total population.

rural_data <- read_xls("data/rural_pop.xls", sheet = 1, range = "A4:BL270")
head(rural_data)
# A tibble: 6 × 64
  `Country Name`      `Country Code` `Indicator Name` `Indicator Code`
  <chr>               <chr>          <chr>            <chr>           
1 Aruba               ABW            Rural populatio… SP.RUR.TOTL.ZS  
2 Africa Eastern and… AFE            Rural populatio… SP.RUR.TOTL.ZS  
3 Afghanistan         AFG            Rural populatio… SP.RUR.TOTL.ZS  
4 Africa Western and… AFW            Rural populatio… SP.RUR.TOTL.ZS  
5 Angola              AGO            Rural populatio… SP.RUR.TOTL.ZS  
6 Albania             ALB            Rural populatio… SP.RUR.TOTL.ZS  
# ℹ 60 more variables: `1960` <dbl>, `1961` <dbl>, `1962` <dbl>,
#   `1963` <dbl>, `1964` <dbl>, `1965` <dbl>, `1966` <dbl>,
#   `1967` <dbl>, `1968` <dbl>, `1969` <dbl>, `1970` <dbl>,
#   `1971` <dbl>, `1972` <dbl>, `1973` <dbl>, `1974` <dbl>,
#   `1975` <dbl>, `1976` <dbl>, `1977` <dbl>, `1978` <dbl>,
#   `1979` <dbl>, `1980` <dbl>, `1981` <dbl>, `1982` <dbl>,
#   `1983` <dbl>, `1984` <dbl>, `1985` <dbl>, `1986` <dbl>, …
# selecting only the relevant year
rural_data <- rural_data |> 
  select(`Country Name`, `Country Code`, `2019`) |> 
  clean_names() |> 
  rename("rural_pop_percentage" = "x2019")

rural_data <- rural_data |> 
  inner_join(select(codelist, iso3c), by = c("country_code" = "iso3c"))

str(rural_data)
tibble [28 × 3] (S3: tbl_df/tbl/data.frame)
 $ country_name        : chr [1:28] "Austria" "Belgium" "Bulgaria" "Cyprus" ...
 $ country_code        : chr [1:28] "AUT" "BEL" "BGR" "CYP" ...
 $ rural_pop_percentage: num [1:28] 41.48 1.96 24.65 33.2 26.08 ...

LGBT rights

Found this LGBT rights index on Our World in Data (https://ourworldindata.org/grapher/lgbt-rights-index) which captures whether LGBT+ people enjoy the same rights as cisgender people combining information on 18 different policies. It includes the legal status of same-sex marriage.

lgbt_rights_index <- read.csv("data/lgbt-rights-index.csv")

lgbt_rights_index <- lgbt_rights_index |> 
  filter(Year == 2019) |> 
  inner_join(select(codelist, iso3c), by = c("Code" = "iso3c")) |> 
  select(-Year) # all observations are from 2019

str(lgbt_rights_index)
'data.frame':   28 obs. of  3 variables:
 $ Entity            : chr  "Austria" "Belgium" "Bulgaria" "Croatia" ...
 $ Code              : chr  "AUT" "BEL" "BGR" "HRV" ...
 $ LGBT..Policy.Index: num  8.92 10 4.94 6.96 3.95 ...

Column names can be renamed:

lgbt_rights_index <- lgbt_rights_index |> 
  rename(country_name = Entity,
         country_code = Code,
         lgbt_policy_index = LGBT..Policy.Index) 

Gender inequality index

Gender Development and Gender Inequality indexes, developed by the United Nations Development. Retrieved from https://hdr.undp.org/data-center/documentation-and-downloads for the year 2019.

gender_index <- read_xlsx("data/UNDP_gender_indexes.xlsx")

gender_index <- gender_index |>
  select(-dimension, -note, -year) |> # empty/useless columns
  inner_join(select(codelist, iso3c), by = c("countryIsoCode" = "iso3c"))

gender_index |> 
  distinct(country) |> 
  nrow()
[1] 28
str(gender_index)
tibble [560 × 7] (S3: tbl_df/tbl/data.frame)
 $ countryIsoCode: chr [1:560] "AUT" "AUT" "AUT" "AUT" ...
 $ country       : chr [1:560] "Austria" "Austria" "Austria" "Austria" ...
 $ indexCode     : chr [1:560] "GII" "GDI" "GDI" "GDI" ...
 $ index         : chr [1:560] "Gender Inequality Index" "Gender Development Index" "Gender Development Index" "Gender Development Index" ...
 $ indicatorCode : chr [1:560] "abr" "eys_f" "eys_m" "gdi" ...
 $ indicator     : chr [1:560] "Adolescent Birth Rate (births per 1,000 women ages 15-19)" "Expected Years of Schooling, female (years)" "Expected Years of Schooling, male (years)" "Gender Development Index (value)" ...
 $ value         : num [1:560] 5.499 16.451 15.725 0.969 0.053 ...

We checked that we have indeed 28 distinct countries in the dataset.

This dataset collects many indicators apart from the indexes values. We are selecting only the Gender Development and Gender Inequality indexes (GDI and GII):

gender_index <- gender_index |> 
  filter(indicatorCode %in% c("gdi", "gii")) |> 
  select(-c(indexCode, indicatorCode, indicator)) |> # removing redundant columns
  pivot_wider(names_from = index, values_from = value)

colnames(gender_index) <- janitor::make_clean_names(colnames(gender_index)) # cleaning spaces and upper cases

And then exploring them to see which one is a better fit for modeling and predictions:

summary(gender_index$gender_inequality_index)
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
 0.0160  0.0555  0.0890  0.1067  0.1335  0.2390 
summary(gender_index$gender_development_index)
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
 0.9560  0.9725  0.9855  0.9856  0.9918  1.0230 
sd(gender_index$gender_inequality_index)
[1] 0.06664423
sd(gender_index$gender_development_index)
[1] 0.0167627

We observe that the second one (Gender Development Index) has a very small range, indicating that most countries have nearly identical scores. This is supported by the standard deviation, which shows that the GII is more spread out than the GDI. Being almost constant, GDI won’t add much value to the analysis. This is likely due to the fact that these indexes are created by the United Nations Development Programme for all countries, so it may not capture the finer differences between EU countries.

cor(gender_index$gender_inequality_index, 
    gender_index$gender_development_index, 
    use = "complete.obs")
[1] 0.1750589

Surprisingly, the two indexes have a very weak positive correlation. While they are not inverse, we interpreted them as measuring opposite things, and had expected a negative correlation. Maybe the correlation coefficient is not useful here because of the low variation of both variables (specially GDI), so ultimately we chose to keep GII and discard GDI.

gender_index <- gender_index |> 
  select(-gender_development_index)

Economist’s Democracy Index

democracy_index <- read_xlsx("data/EIU_democracy_index.xlsx", sheet = 4)

# the ISO codes were lowercase which impedes the join
democracy_index$geo <- toupper(democracy_index$geo)

# filter for 2019 and EU28 countries
democracy_index <- democracy_index |> 
  filter(time == 2019) |> 
  inner_join((select(codelist, iso3c)), by = c("geo" = "iso3c"))

# clean var names
names(democracy_index) <- names(democracy_index) %>%
  janitor::make_clean_names() %>%
  gsub("_eiu$", "", .)

democracy_index <- democracy_index |> 
  rename(country_code = geo,
         country_name = name,
         year = time)

str(democracy_index)
tibble [28 × 10] (S3: tbl_df/tbl/data.frame)
 $ country_code                 : chr [1:28] "AUT" "BEL" "BGR" "HRV" ...
 $ country_name                 : chr [1:28] "Austria" "Belgium" "Bulgaria" "Croatia" ...
 $ year                         : num [1:28] 2019 2019 2019 2019 2019 ...
 $ democracy_index              : num [1:28] 82.9 76.4 70.3 65.7 75.9 76.9 92.2 79 92.5 81.2 ...
 $ electoral_pluralism_index    : num [1:28] 95.8 95.8 91.7 91.7 91.7 95.8 100 95.8 100 95.8 ...
 $ government_index             : num [1:28] 78.6 82.1 64.3 60.7 64.3 67.9 92.9 78.6 89.3 78.6 ...
 $ political_participation_index: num [1:28] 83.3 50 72.2 55.6 66.7 66.7 83.3 66.7 88.9 77.8 ...
 $ political_culture_index      : num [1:28] 68.8 68.8 43.8 50 68.8 68.8 93.8 68.8 87.5 68.8 ...
 $ civil_liberties_index        : num [1:28] 88.2 85.3 79.4 70.6 88.2 85.3 91.2 85.3 97.1 85.3 ...
 $ change_in_democracy_index    : num [1:28] 0 -1.4 0 0 0 ...

In this case, we are only keeping the overall index value.

democracy_index <- democracy_index |> 
  select(country_name, country_code, democracy_index)

Joining all country-level data together

country_level_data <- codelist |> 
  select(iso3c, iso2c) |> 
  left_join(gdp_data, by = c("iso3c" = "country_code")) |> 
  # left_join(rural_data, by = c("iso3c" = "country_code")) |> rural population data will probably be discarded
  left_join(gender_index, by = c("iso3c" = "country_iso_code")) |> 
  left_join(lgbt_rights_index, by = c("iso3c" = "country_code")) |> 
  left_join(democracy_index, by = c("iso3c" = "country_code")) |> 
  select(-contains("country_")) # removing all duplicated country_name columns that were joined from each data frame
str(country_level_data)
tibble [28 × 7] (S3: tbl_df/tbl/data.frame)
 $ iso3c                  : chr [1:28] "AUT" "BEL" "BGR" "HRV" ...
 $ iso2c                  : chr [1:28] "AT" "BE" "BG" "HR" ...
 $ gdp_pc_ppp             : num [1:28] 64630 60452 27673 35094 46157 ...
 $ country                : chr [1:28] "Austria" "Belgium" "Bulgaria" "Croatia" ...
 $ gender_inequality_index: num [1:28] 0.053 0.048 0.205 0.119 0.235 0.124 0.016 0.092 0.031 0.086 ...
 $ lgbt_policy_index      : num [1:28] 8.92 10 4.94 6.96 3.95 ...
 $ democracy_index        : num [1:28] 82.9 76.4 70.3 65.7 75.9 76.9 92.2 79 92.5 81.2 ...

Data cleaning

Selecting relevant variables

We are discarding all variables that relate to trade and globalization as deemed not relevant for our analysis qa. We are also discarding variables related to energy policies qb.

We have also not considered questions specifically about Roma ex qc8 and qc14 and qc16


Some of the doubts we had:

AGE

x_df <- data_raw |> summarise(mean = mean(qc19), .by = d11)
ggplot(x_df, aes(x = d11, y = mean)) + geom_point()

As relationship seems pretty linear we are going to use the continuous variable for age and there seems to be a clear group (1to4) which is the same used in the variable with 3 categories left, center and right so we will use the 3-categories variable


POLITICAL OPINIONS

x_df <- data_raw |> summarise(mean = mean(qc19), .by = d1)
ggplot(x_df, aes(x = d1, y = mean)) + geom_point() + xlim(1,10)

For political opinions it seems that the relationship is less linear so we will work on the 5 categories cod


MARRIAGE

x_df <- data_raw |> summarise(mean = mean(qc19), .by = d7r1)
ggplot(x_df, aes(x = d7r1, y = mean)) + geom_point() + xlim(1,5)

Of all the possible combinations this one seems the best to highlight differences in our target variable


NATIONALITY

There is no easy way to create an immigrant dummy by checking whether someone does not have the nationality of the country in which he is being interviewed for the survey. So we are just going to use q1_29 as a dummy for whether someone owns a non-EU nationality


POLITICAL INTEREST

Using only polintr as a summary of the whole d71 question about how strong is your interest in politics in various domains


EXPERIENCED DISCRIMINATION

For the questions about whether you have experienced discrimination qc2_ I am keeping only qc2_15 which is a binary on whether you have experienced any discrimination or not and I am not keeping the other categories that allowed us to understand if you had experienced discrimination on the basis of a particular motive. We can probably assume that if a person is a part of a specific minority (info from sd2) and is being discriminated is because of being part of that minority (at least in most cases), therefore it felt like information we already had (and which we can easily put in our regression using interaction effects)


PERCIEVED DISCRIMINATION in country

This is a question (qc1) about how widespread you perceived discrimination is in your country. It is a rather peculiar question because it asks individuals for perception at the country level. I think it might be more useful (by aggregating results by country) to use it to build a country level indicator of perceived discrimination against certain minorities that are of our interest rather than use it as an individual level variable. So I will keep them out of the dataset for now

For the same reason I am also discarding qc4 that asks whether in your country you feel like candidates with certain characteristics would be at a disadvantage in the recruitment process. It still basically asks about perceived discrimination at the country level.

And the same reasoning also applies to qc7 which asks if efforts towards reducing discrimination are effective in your country.


HOW DISCRIMINATORY ARE YOU score

I use qc12 and qc13 to build a score from 1 to 10 of how discriminatory are you against certain minorities. I am building the score for each minority and then we can decide later if some are irrelevant.

Note for some categories this score is a bit stupid (ex. voting for whether you would feel uncomfortable if your child was in a love relationship with a old person would give you a high racist score against old people, this is an example of some of the categories for which it is worth excluding the index)

We can also further aggregate to obtain just one score (or obtain religious/ethnic score etc.).

qc6 also asks about discriminatory behaviors, but is about elected public official, it does not ask about a situation that impacts you personally. It also uses different categories for minorities therefore I prefer to use qc12 and qc13 rather than qc6.


SUPPORTIVE OF LGBTQ RIGHTS INDEX

Using qc15 we can again build an index for how supportive of lgbtq rights a person is.

I again choose to take the mean across the different answers but we could also use median/mode if we think is better

We could also use qc18 to try to capture anti lgbtq sentiment, but I preferred qc15 as it seemed more straightforward (I therefore deleted qc18, but we can put it back if useful).


MY VOICE COUNTS

I guess that people that feel alienated from society and politics might be less likely to support lgbtq rights so I took the mean of d72 question which asked whether you felt like your voice mattered.


OTHERS

qc11 is a strange question feels useless to me, I removed it.

I also removed qc9 as I don’t really know what to do with it and qc17.

data <- data_raw |> 
  select(serialid, # unique identifier
         isocntry, # 2 digit country code
         d11, # age variables
         q1_29, # nationality of interviewee. options given: EU28+Other+DK, using only other = outside of EU
         d70, #life satisfaction
         polintr, # political interest index (summarizes d71 questions)
         starts_with("sd1"), # friends that are minority groups
         starts_with("sd2"), # are you part of a minority
         sd3, # religion
         qc2_15, # experienced discrimination yourself
         qc3, # where discrimination took place
         starts_with("qc5"), # actions against discrimination
         qc10, # how would you report discrimination
         starts_with("qc12"), # feelings about colleagues being minority
         starts_with("qc13"), # feelings about kid being in a relationship with minority
         starts_with("qc15"), # opinions about lgbtqi 
         qc19, # target variable transgender
         qc20, # non-binary genders in documents
         d1r1, # political ideology
         d7r1, # marital status
         d10, # gender binary
         d8, # eduaction 
         d15a_r2, # current occupation (discarded previous occupation d15b)
         d25, # rural vs urban
         d43t, # phones availiabilty
         d60, # financial stress (paying bills)
         netuse, # internet index
         d63, # social class
         starts_with("d72"), # my voice counts
  )

paradata <- data_raw |> 
  select(serialid, # to match it with the other data
         p2, p3, p3r, p4, p5) # paradata)

Removing some of the previously selected variables

sd2_7 to sd2_10: these are possible answer deemed irrelevant to the question about yourself being part of the following minorities: sd2_7 other minorities (I don’t know what other relevant minorities could be there), sd2_8 not part of minorities (can be deducted from the rest), sd2_9 refusal to respond, sd2_10 DK answers sd2t summary binary variable for being part of any minority (we are going to keep the more specific one)

I also remove qc12_nr as I prefer to work on the full variable instead of the recoded version with less categories. Same for qc13 and qc18

data <- data |> 
  # Keep in mind that sd2t does not have NAs so we might want to use that instead of the more specific ones
  select(-c(sd2_7, sd2_8, sd2_9, sd2_10, sd2t)) |> 
  select(-(starts_with("qc12") & ends_with("r"))) |> 
  select(-(starts_with("qc13") & ends_with("r"))) |> 
  select(-(starts_with("qc18") & ends_with("r")))

Check overall data quality

explore_tbl(data)
plot_intro(data)

All columns are numeric columns, the only one which is not is isocntry

data |> 
  select(where(~ !is.numeric(.)))
# A tibble: 27,438 × 1
   isocntry
   <chr>   
 1 BE      
 2 BE      
 3 BE      
 4 BE      
 5 BE      
 6 BE      
 7 BE      
 8 BE      
 9 BE      
10 BE      
# ℹ 27,428 more rows

Most columns do not have explicit NAs

plot_missing(data)
names(which(colSums(is.na(data)) > 0))
[1] "qc3"

Exploiting the fact that the .dta files has attributes (labels) for all its columns.

If we search for attr(colname, "label") you get back the original long name of the variable

If we instead search for attr(colname, "labels") you get back all the possible encoding levels of the variable (ex.1,2,3,4 etc.) and by doing names(attr(colname, "labels")) you get back the actual meaning of those numbers (ex. 1 = “Yes”, 2 = “No”, etc.)

Will now look into the labels for the different levels that our factor variables can take:

attr(data$d70, "labels")
      Very satisfied     Fairly satisfied   Not very satisfied 
                   1                    2                    3 
Not at all satisfied                   DK 
                   4                    5 
names(attr(data$d70, "labels"))
[1] "Very satisfied"       "Fairly satisfied"    
[3] "Not very satisfied"   "Not at all satisfied"
[5] "DK"                  
tibble(name_labels = names(attr(data$d70, "labels")),
       labels = attr(data$d70, "labels"))
# A tibble: 5 × 2
  name_labels          labels
  <chr>                 <dbl>
1 Very satisfied            1
2 Fairly satisfied          2
3 Not very satisfied        3
4 Not at all satisfied      4
5 DK                        5
# Create a list of tibbles containing the labels and their associated name for each variable
list_label_tibbles <- 
  #Applies a function across all columns of a df and returns results as a list
  lapply(names(data), function(col_name) {
    labels <- attr(data[[col_name]], "labels")  # Extract labels
    name_labels <- names(labels)  # Extract label names
    # Create tibble with the extracted data only if labels exist
    if (!is.null(labels)) {
      tibble(name_labels = name_labels, labels = labels)} 
    else {NULL}  # Returns a NULL element for columns without labels
  })

# Giving to each element of the list as name the name of the variable
list_label_tibbles <- setNames(list_label_tibbles, names(data))

# For example
list_label_tibbles$d70
# A tibble: 5 × 2
  name_labels          labels
  <chr>                 <dbl>
1 Very satisfied            1
2 Fairly satisfied          2
3 Not very satisfied        3
4 Not at all satisfied      4
5 DK                        5

Right column is what appears in our data (as a number). Left column is the label that we must assign to that number when we factorize

Cleaning

Initial cleaning and pre-processing

Recoding together Germany East and West because we are running analysis at the country level and they are coded separately.

unique(data$isocntry)
 [1] "BE"   "DK"   "GR"   "ES"   "FI"   "FR"   "IE"   "IT"   "LU"  
[10] "NL"   "AT"   "PT"   "SE"   "DE-W" "DE-E" "GB"   "BG"   "CY"  
[19] "CZ"   "EE"   "HU"   "LV"   "LT"   "MT"   "PL"   "RO"   "SK"  
[28] "SI"   "HR"  
data <- data |> 
  mutate(isocntry = case_when(
    isocntry %in% c("DE-W", "DE-E") ~ "DE",
    TRUE ~ isocntry))
# We might want to join the full name of the countries using the codelist df

Separating variables for which I can use the attribute labels to factorize them and the variables for which this strategy cannot be used

data <- data |> 
  rename(friends_trans = sd1_7)

non_factor_variables <- c("serialid", "tnscntry", "isocntry", "d11", "q1_29", 
                          names(data)[startsWith(names(data), "sd1_")],
                          names(data)[startsWith(names(data), "sd2_")],
                          names(data)[startsWith(names(data), "qc5_")],
                          names(data)[startsWith(names(data), "qc12_")],
                          names(data)[startsWith(names(data), "qc13_")],
                          names(data)[startsWith(names(data), "qc15_")],
                          names(data)[startsWith(names(data), "d72_")],
                          "d8", "opls")
factor_variables <- setdiff(names(data), non_factor_variables)

Correctly encoding the factor variables that do not need any further cleaning

# Converting them to factors and assign them their labels automatically
data <- data |> 
  mutate(across(all_of(factor_variables), labelled::to_factor))

# Turning DK into NAs for all the factor variables
data <- data |> 
  mutate(across(all_of(factor_variables), ~ fct_na_level_to_value(., extra_levels = "DK")))

# Converting to numeric the variables that should be numeric
# They are already numeric but they carry with them some labels as well that only confuse us, by doing this I remove the labels
data <- data |> 
  mutate(age = as.numeric(d11),
         years_edu = as.numeric(d8)) |> 
  # Recoding correctly d8 education variable according to unique(data_raw$d11))
  mutate(years_edu = case_when(
    years_edu %in% c(0, 99) ~ NA, # Refusal and DK as NAs
    years_edu == 97 ~ 0, # No full time education = 0
    years_edu == 98 ~ age, # still studying = age
    TRUE ~ years_edu)) |> 
  select(-c(d11, d8))

# Converting q1_29 to factor without assigning labels (1 if non-Eu nationality, 0 if EU nationality)
# Same for sd2_
data <- data |> 
  mutate(nonEU_national = as.factor(q1_29),
         across(starts_with("sd2_"), ~ as.factor(.x))) |> 
  select(-q1_29)

Dealing with the other variables on which we do some further pre-processing (feature engineering)

# Creating a variable that counts the number of different minority groups a person has acquaintances with
data <- data |>  
  mutate(across(starts_with("sd1"), ~ if_else(.x == 1, 1, 0))) |> 
  mutate(n_friends_minorities = sd1_1+sd1_2+sd1_3+sd1_4+sd1_5+sd1_6+sd1_8) |> 
  relocate(n_friends_minorities, .before="sd1_1") |> 
  select(-starts_with("sd1"))
# Creating a variable that counts the number of actions against discrimination that you have taken in the last year
data <- data |>  
  mutate(across(starts_with("qc5"), ~ if_else(.x == 1, 1, 0))) |> 
  mutate(n_actions_against_discri = qc5_1+qc5_2+qc5_3+qc5_4) |> 
  relocate(n_actions_against_discri, .after="qc3") |> 
  select(-starts_with("qc5"))
# Building a discriminatory score
data <- data |> 
  # Coding as NAs "it depends" and "DK"
  mutate(across(starts_with("qc12"), ~ if_else(.x >= 12, NA, .x))) |> 
  mutate(across(starts_with("qc13"), ~ if_else(.x >= 12, NA, .x))) |> 
  # Coding as 5 responses = indifferent
  mutate(across(starts_with("qc12"), ~ if_else(.x == 11, 5, .x))) |> 
  mutate(across(starts_with("qc13"), ~ if_else(.x == 11, 5, .x))) |> 
  # Modifying such that higher is more discriminatory
  mutate(roma_discri = 11 - rowMeans(cbind(qc12_1, qc13_1), na.rm = TRUE),
         black_discri = 11 - rowMeans(cbind(qc12_2, qc13_2), na.rm = TRUE),
         asian_discri = 11 - rowMeans(cbind(qc12_3, qc13_3), na.rm = TRUE),
         white_discri = 11 - rowMeans(cbind(qc12_4, qc13_4), na.rm = TRUE),
         jewish_discri = 11 - rowMeans(cbind(qc12_5, qc13_5), na.rm = TRUE),
         muslim_discri = 11 - rowMeans(cbind(qc12_6, qc13_6), na.rm = TRUE),
         buddihst_discri = 11 - rowMeans(cbind(qc12_7, qc13_7), na.rm = TRUE),
         christian_discri = 11 - rowMeans(cbind(qc12_8, qc13_8), na.rm = TRUE),
         atheist_discri = 11 - rowMeans(cbind(qc12_9, qc13_9), na.rm = TRUE),
         lgb_discri = 11 - rowMeans(cbind(qc12_10, qc13_10), na.rm = TRUE),
         trans_discri = 11 - rowMeans(cbind(qc12_11, qc13_11), na.rm = TRUE),
         intersex_discri = 11 - rowMeans(cbind(qc12_12, qc13_12), na.rm = TRUE),
         disability_discri = 11 - rowMeans(cbind(qc12_13, qc13_13), na.rm = TRUE),
         young_discri = 11 - rowMeans(cbind(qc12_14, qc13_14), na.rm = TRUE),
         old_discri = 11 - rowMeans(cbind(qc12_15, qc13_15), na.rm = TRUE)) |> 
  select(-starts_with("qc12")) |> 
  select(-starts_with("qc13"))

# I am deleting the discrimination index against young and old people
# This is because one of the question is: how comfortable you would feel if one of your children was in a love relationship with a person from group x.
# It is totally acceptable that people would not feel comfortable with their kid dating an old person without that meaning that they are being discriminatory against old people
data <- data |> 
  select(-c("old_discri", "young_discri"))
# Supportive/anti lbtq rights index
data <- data |> 
  mutate(across(starts_with("qc15"), ~ if_else(.x == 5, NA, .x))) |>
  mutate(antilgbtq_rights = round(rowMeans(cbind(qc15_1, qc15_2, qc15_3), na.rm = TRUE), 2)) |> 
  select(-starts_with("qc15"))
# Scale of 1 to 4, 1 = supportive, 4 = homophobic
# My voice counts index
data <- data |> 
  mutate(across(starts_with("d72"), ~ if_else(.x > 4, NA, .x))) |>
  mutate(social_alienation = rowMeans(cbind(d72_1, d72_2), na.rm = TRUE)) |> 
  select(-starts_with("d72"))
# The higher the more people think their voice does not matter

This should be our final selection of variables.

We still need to rename them appropriately and check that all the NAs are correctly encoded by looking at the summary.

Further cleaning

Rename columns appropriately

data <- data |> 
  rename(
    country = isocntry,
    life_sat = d70,
    ethnic_minority = sd2_1,
    skincolor_minority = sd2_2,
    religious_minority = sd2_3,
    roma_minority = sd2_4,
    sexual_minority = sd2_5,
    disability_minority = sd2_6,
    religion = sd3,
    disc = qc2_15,
    disc_where = qc3,
    disc_contact = qc10,
    trans_docs = qc19,
    gender_docs = qc20,
    left_right = d1r1,
    marital_status = d7r1,
    gender = d10,
    occupation = d15a_r2,
    community = d25,
    phone_access = d43t,
    bill_issues = d60,
    internet_use = netuse,
    social_class = d63
  ) 

Now, we will transform the variable disc, which was originally coded in a negative way (1 = “Not mentioned”, 2 = “No, you haven’t been discriminated against”), into a positive dummy variable to make its interpretation more straightforward. The variable is 1 if a person has been subject to discrimination

data <- data |> 
  mutate(suffered_discr = as.factor(ifelse(disc == "Not mentioned", 1, 0))) |> 
  select(-disc) |> 
  relocate(suffered_discr, .before = disc_where)

Move the variables around to have a ordered dataframe

# Relocating to have a ordered df
data <- data |> 
  relocate(c("age", "gender", "years_edu","community", "marital_status", "occupation", "social_class", "religion", "nonEU_national", "phone_access", "bill_issues", "internet_use"), .after = country) |> 
  relocate(c("left_right", "social_alienation"), .after = polintr) |> 
  relocate(c("friends_trans", "n_friends_minorities", "n_actions_against_discri"), .after = gender_docs)

# Assigning labels to columns which have a difficult meaning
attr(data$gender, "label") <- NULL
attr(data$nonEU_national, "label") <- "OWNS A NON-EU NATIONALITY"
attr(data$social_alienation, "label") <- "HIGHER -> THINK THEIR VOICE DOESN'T  MATTER"
attr(data$ethnic_minority, "label") <- "ARE YOU PART OF X MINORITY" 
attr(data$skincolor_minority, "label") <- "ARE YOU PART OF X MINORITY" 
attr(data$religious_minority, "label") <- "ARE YOU PART OF X MINORITY" 
attr(data$roma_minority, "label") <- "ARE YOU PART OF X MINORITY" 
attr(data$sexual_minority, "label") <- "ARE YOU PART OF X MINORITY" 
attr(data$disability_minority, "label") <- "ARE YOU PART OF X MINORITY" 
attr(data$disability_minority, "label") <- "ARE YOU PART OF X MINORITY" 
attr(data$disability_minority, "label") <- "ARE YOU PART OF X MINORITY"
attr(data$suffered_discr, "label") <- "HAVE YOU BEEN SUBJECT TO DISCRIMINATION"
attr(data$n_friends_minorities, "label") <- "YOU KNOW PEOPLE FROM # NUMBER OF DIFFERENT MINORITES"
attr(data$n_actions_against_discri, "label") <- "YOU HAVE DONE # NUMBER OF DIFFERENT ACTIONS TO FIGHT DISCRIMINATIONS"
attr(data$roma_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$black_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$asian_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$white_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$jewish_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$muslim_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$buddihst_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$christian_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$atheist_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$atheist_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$lgb_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$trans_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$intersex_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$disability_discri, "label") <- "HOW DISCRIMINATORY ARE YOU AGAINST X"
attr(data$antilgbtq_rights, "label") <- "HIGHER -> THEY OPPOSE MORE RIGHTS TO LGBTQ"
summary(data)
    serialid       country               age          gender     
 Min.   :    1   Length:27438       Min.   :15.00   Man  :12492  
 1st Qu.: 6860   Class :character   1st Qu.:37.00   Woman:14946  
 Median :13720   Mode  :character   Median :53.00                
 Mean   :13720                      Mean   :51.56                
 3rd Qu.:20579                      3rd Qu.:66.00                
 Max.   :27438                      Max.   :98.00                
                                                                 
   years_edu                          community    
 Min.   : 0.00   Rural area or village     : 8776  
 1st Qu.:17.00   Small or middle sized town:10767  
 Median :18.00   Large town                : 7881  
 Mean   :19.66   NA's                      :   14  
 3rd Qu.:22.00                                     
 Max.   :90.00                                     
 NA's   :387                                       
                                marital_status 
 (Re-)Married (1-4 in d7)              :14673  
 Single living with partner (5-8 in d7): 3321  
 Single (9-10 in d7)                   : 4314  
 Divorced or separated (11-12 in d7)   : 2243  
 Widow (13-14 in d7)                   : 2712  
 Other (SPONT.)                        :  107  
 Refusal (SPONT.)                      :   68  
                                  occupation  
 Retired (4 in d15a)                   :8791  
 Manual workers (15 to 18 in d15a)     :5883  
 Other white collars (13 or 14 in d15a):3536  
 Managers (10 to 12 in d15a)           :2911  
 Self-employed (5 to 9 in d15a)        :1979  
 Students (2 in d15a)                  :1676  
 (Other)                               :2662  
                            social_class  
 The middle class of society      :13068  
 The working class of society     : 7233  
 The lower middle class of society: 4070  
 The upper middle class of society: 1889  
 None (SPONTANEOUS)               :  229  
 (Other)                          :  389  
 NA's                             :  560  
                     religion     nonEU_national
 Catholic                :11198   0:27316       
 Orthodox Christian      : 4016   1:  122       
 Non believer or agnostic: 3694                 
 Protestant              : 3031                 
 Atheist                 : 2109                 
 (Other)                 : 3220                 
 NA's                    :  170                 
            phone_access               bill_issues   
 Mobile only      :14555   Most of the time  : 2054  
 Landline only    :  802   From time to time : 6538  
 Landline & mobile:11576   Almost never/never:18467  
 No telephone     :  505   Refusal (SPONT.)  :  379  
                                                     
                                                     
                                                     
                     internet_use                   life_sat    
 Everyday/Almost everyday  :19900   Very satisfied      : 7242  
 Two or three times a week : 1701   Fairly satisfied    :15356  
 About once a week         :  434   Not very satisfied  : 3736  
 Two or three times a month:  164   Not at all satisfied: 1002  
 Less often                :  350   NA's                :  102  
 Never/No access           : 4311                               
 No Internet access at all :  578                               
       polintr               left_right   social_alienation
 Strong    : 4644   (1 - 4) Left  :7082   Min.   :1.000    
 Medium    :13701   (5 - 6) Centre:9313   1st Qu.:1.500    
 Low       : 4387   (7 -10) Right :6354   Median :2.000    
 Not at all: 4706   DK/Refusal    :4689   Mean   :2.329    
                                          3rd Qu.:3.000    
                                          Max.   :4.000    
                                          NA's   :1000     
 ethnic_minority skincolor_minority religious_minority roma_minority
 0:26603         0:26923            0:26416            0:27001      
 1:  835         1:  515            1: 1022            1:  437      
                                                                    
                                                                    
                                                                    
                                                                    
                                                                    
 sexual_minority disability_minority suffered_discr
 0:27006         0:26756             0:23150       
 1:  432         1:  682             1: 4288       
                                                   
                                                   
                                                   
                                                   
                                                   
                                                          disc_where   
 In a public space                                             :  893  
 At work                                                       :  788  
 When looking for a job                                        :  642  
 At a café, restaurant, bar or nightclub                       :  322  
 By healthcare personnel (e.g. a receptionist, nurse or doctor):  308  
 (Other)                                                       : 1054  
 NA's                                                          :23431  
                                                                      disc_contact 
 The police                                                                 :8769  
 A friend or family member                                                  :5386  
 An equalities body or ombudsman (SPECIFY THE NAME ACCORDING TO THE COUNTRY):3795  
 A lawyer                                                                   :2329  
 Courts                                                                     :1225  
 (Other)                                                                    :3601  
 NA's                                                                       :2333  
 trans_docs   gender_docs                friends_trans  
 Yes :14463   Yes :10856   Yes                  : 2644  
 No  : 9695   No  :13395   No                   :23520  
 NA's: 3280   NA's: 3187   Refusal (SPONTANEOUS):  306  
                           NA's                 :  968  
                                                        
                                                        
                                                        
 n_friends_minorities n_actions_against_discri  roma_discri    
 Min.   :0.000        Min.   :0.0000           Min.   : 1.000  
 1st Qu.:1.000        1st Qu.:0.0000           1st Qu.: 1.500  
 Median :3.000        Median :0.0000           Median : 4.500  
 Mean   :3.029        Mean   :0.3855           Mean   : 4.631  
 3rd Qu.:5.000        3rd Qu.:0.0000           3rd Qu.: 7.000  
 Max.   :7.000        Max.   :4.0000           Max.   :10.000  
                                               NA's   :757     
  black_discri     asian_discri     white_discri    jewish_discri  
 Min.   : 1.000   Min.   : 1.000   Min.   : 1.000   Min.   : 1.00  
 1st Qu.: 1.000   1st Qu.: 1.000   1st Qu.: 1.000   1st Qu.: 1.00  
 Median : 3.000   Median : 2.500   Median : 1.000   Median : 2.00  
 Mean   : 3.579   Mean   : 3.387   Mean   : 1.785   Mean   : 3.18  
 3rd Qu.: 5.500   3rd Qu.: 5.500   3rd Qu.: 2.000   3rd Qu.: 5.00  
 Max.   :10.000   Max.   :10.000   Max.   :10.000   Max.   :10.00  
 NA's   :542      NA's   :592      NA's   :403      NA's   :603    
 muslim_discri    buddihst_discri  christian_discri atheist_discri  
 Min.   : 1.000   Min.   : 1.000   Min.   : 1.000   Min.   : 1.000  
 1st Qu.: 1.000   1st Qu.: 1.000   1st Qu.: 1.000   1st Qu.: 1.000  
 Median : 4.000   Median : 3.000   Median : 1.000   Median : 1.500  
 Mean   : 4.363   Mean   : 3.576   Mean   : 1.904   Mean   : 2.802  
 3rd Qu.: 6.500   3rd Qu.: 5.500   3rd Qu.: 2.000   3rd Qu.: 4.000  
 Max.   :10.000   Max.   :10.000   Max.   :10.000   Max.   :10.000  
 NA's   :662      NA's   :761      NA's   :414      NA's   :517     
   lgb_discri      trans_discri    intersex_discri  disability_discri
 Min.   : 1.000   Min.   : 1.000   Min.   : 1.000   Min.   : 1.000   
 1st Qu.: 1.000   1st Qu.: 2.000   1st Qu.: 1.500   1st Qu.: 1.000   
 Median : 4.000   Median : 5.000   Median : 5.000   Median : 2.500   
 Mean   : 4.399   Mean   : 4.934   Mean   : 4.825   Mean   : 2.977   
 3rd Qu.: 6.500   3rd Qu.: 7.500   3rd Qu.: 7.500   3rd Qu.: 4.500   
 Max.   :10.000   Max.   :10.000   Max.   :10.000   Max.   :10.000   
 NA's   :536      NA's   :1081     NA's   :1331     NA's   :585      
 antilgbtq_rights
 Min.   :1.000   
 1st Qu.:1.000   
 Median :2.000   
 Mean   :2.147   
 3rd Qu.:3.000   
 Max.   :4.000   
 NA's   :791     

Our dataset seems quite balanced across the different countries

data |> count(country)
# A tibble: 28 × 2
   country     n
   <chr>   <int>
 1 AT       1027
 2 BE       1028
 3 BG       1032
 4 CY        503
 5 CZ       1008
 6 DE       1537
 7 DK       1004
 8 EE       1003
 9 ES       1005
10 FI       1003
# ℹ 18 more rows

Although some levels of occupation have more observations than others, we have enough observations for each level so we do not need to aggregate over different levels for the variable occupation

data |> count(occupation)
# A tibble: 8 × 2
  occupation                                 n
  <fct>                                  <int>
1 Self-employed (5 to 9 in d15a)          1979
2 Managers (10 to 12 in d15a)             2911
3 Other white collars (13 or 14 in d15a)  3536
4 Manual workers (15 to 18 in d15a)       5883
5 House persons (1 in d15a)               1358
6 Unemployed (3 in d15a)                  1304
7 Retired (4 in d15a)                     8791
8 Students (2 in d15a)                    1676

Very few people declare themselves to be the higher class of society, nonetheless we keep this level because it makes sense

data |> count(social_class)
# A tibble: 9 × 2
  social_class                          n
  <fct>                             <int>
1 The working class of society       7233
2 The lower middle class of society  4070
3 The middle class of society       13068
4 The upper middle class of society  1889
5 The higher class of society         157
6 Other (SPONTANEOUS)                  59
7 None (SPONTANEOUS)                  229
8 Refusal (SPONTANEOUS)               173
9 <NA>                                560

Given the low number of observations in some categories of the variable religion and the high number of categories we opt to aggregate some of them, otherwise we risk too much noise in our models.

data |> count(religion)
# A tibble: 16 × 2
   religion                     n
   <fct>                    <int>
 1 Catholic                 11198
 2 Orthodox Christian        4016
 3 Protestant                3031
 4 Other Christian           1183
 5 Jewish                      58
 6 Muslim - Shia               77
 7 Muslim - Sunni             178
 8 Other Muslim               137
 9 Sikh                        13
10 Buddhist                    58
11 Hindu                       32
12 Atheist                   2109
13 Non believer or agnostic  3694
14 Other                     1171
15 Refusal (SPONTANEOUS)      313
16 <NA>                       170
# Checking if the means of groups we are going to aggregate are similar
data |> 
  mutate(trans_docs=as.numeric(trans_docs)) |> 
  summarise(mean = mean(trans_docs, na.rm=TRUE), .by = religion) |>
  arrange(mean)
# A tibble: 16 × 2
   religion                  mean
   <fct>                    <dbl>
 1 Sikh                      1.25
 2 Atheist                   1.27
 3 Non believer or agnostic  1.28
 4 Protestant                1.30
 5 Buddhist                  1.33
 6 Other                     1.37
 7 Jewish                    1.38
 8 Other Christian           1.43
 9 Catholic                  1.43
10 Hindu                     1.44
11 Muslim - Shia             1.45
12 <NA>                      1.45
13 Other Muslim              1.49
14 Refusal (SPONTANEOUS)     1.49
15 Muslim - Sunni            1.54
16 Orthodox Christian        1.58
# We are going to group together atheist with agnostic
# We are also going to put sikh, buddhists, jewish and hindu into the other category
# Finally we are going to group together all muslims
data <- data |> 
  mutate(religion = fct_collapse(religion,
                                "Non-believers" = c("Atheist", "Non believer or agnostic"),
                                "Other" = c("Sikh", "Buddhist", "Jewish", "Hindu", "Other"),
                                "Muslim" = c("Muslim - Shia", "Muslim - Sunni", "Other Muslim")))

#This is what we end up with
data |> count(religion)
# A tibble: 9 × 2
  religion                  n
  <fct>                 <int>
1 Catholic              11198
2 Orthodox Christian     4016
3 Protestant             3031
4 Other Christian        1183
5 Other                  1332
6 Muslim                  392
7 Non-believers          5803
8 Refusal (SPONTANEOUS)   313
9 <NA>                    170

Recoding missing values

Now we will substitute de “Refusal” answers in the remaining variables as NAs. If the respondent refuses to answer it’s equivalent to not knowing his or her answer. We exclude friends_trans because for that category it could be worth analyzing refusal.

factor_variables <- names(data)[sapply(data, is.factor)]

data <- data %>%
  mutate(across(
    all_of(setdiff(factor_variables, "friends_trans")),  # Exclude "friends_trans"
    ~ {
      # Look for levels that contain "REFUSAL"
      refusal_levels <- grep("REFUSAL", levels(.), value = TRUE, ignore.case = TRUE)
      # If there are levels containing "REFUSAL"
      if (length(refusal_levels) > 0) { 
        # Convert in NA
        fct_recode(., NULL = refusal_levels)  
      } 
      # if not remain without changes
      else {
        .  
      }
    }
  ))

# Mutate NONE level of social class to NA
data <- data %>%
  mutate(social_class = fct_recode(social_class, NULL = "None (SPONTANEOUS)"))

# We turn marital_status level OTHER into NAs, as it is difficult to give it any other meaning. Same for social class
data <- data %>%
  mutate(marital_status = fct_recode(marital_status, NULL = "Other (SPONT.)"),
         social_class = fct_recode(social_class, NULL = "Other (SPONTANEOUS)")) 
plot_intro(data)
plot_missing(data)

The total number of missing observations is quite low (4%) so missing data should not be a huge problem

Given the high percentage of missing values we delete disc_where. This variable was expected to have a high percentage of missingness as it is a question that applies only to people that have been subject to discrimination. So it is not of huge importance

The variable with the second highest number of missing data is left_right, given the importance of this variable it is probably worth to impute those values.

Next there are the variables trans_docs and gender_docs which are respectively our target variable and a closely related variable

Then there is disc_contact which will be deleted as well, given that it does not add meaningful information to our analysis

data <- data |> 
  select(-c("disc_where", "disc_contact"))

Exploratory Data Analysis

Plotting the distribution of the numeric variables

library(e1071)

# Identify numeric variables
numeric_vars <- names(data)[sapply(data, is.numeric)]
numeric_vars <- numeric_vars[numeric_vars != "serialid"]

plot_histogram(data |> select(all_of(numeric_vars)))
# Creating histogramas y calculating skweness
for (var in numeric_vars) {
  p <- ggplot(data, aes(x = .data[[var]])) +
    geom_histogram(binwidth = 1, fill = "blue", color = "black") +
    labs(title = paste("Histogram of", var), x = var, y = "Count") +
    theme_minimal()
  print(p)}

Analysis of individual-level variables

We must keep in mind our Target variable is qc19 “Do you think that transgender persons should be able to change their civil documents to match their inner gender identity?”

data_percent <- data |>
  mutate(trans_docs = fct_na_value_to_level(trans_docs, "Don't Know")) |> 
  group_by(trans_docs) |> 
  summarise(count = n()) |> 
  mutate(percentage = count / sum(count) * 100)

ggplot(data_percent, aes(x = trans_docs, y = percentage, fill = trans_docs)) +
  geom_bar(stat = "identity") +  
  geom_text(aes(label = sprintf("%.1f%%", percentage)),  
            vjust = -0.5, size = 4, color = "black") +  
  scale_y_continuous(labels = scales::percent_format(scale = 1)) + 
  labs(
    title = "Overall distribution of support for trans people to change \ntheir gender in civil documents",
    x = "Support for Transgender Rights",
    y = "Percentage"
  ) +
  theme_minimal() +
  theme(legend.position = "none")

Taking a look to our variable of interest alone, we see how the 52.7% of our sample are in favor of trans people to change their gender in their civil documents. However, there is also a significant opposition (35,3%), and a 12% who answered “Don’t know”. We will try to explore this distribution along the variables we consider to be most important for our analysis.

Sociodemographic variables

Gender

data_summary <- data |> 
  mutate(trans_docs = fct_na_value_to_level(trans_docs, "Don't Know")) |> 
  count(trans_docs, gender, name = "n") |> 
  group_by(gender) |>  
  mutate(percentage = n / sum(n))

ggplot(data_summary, aes(x = gender, y = percentage, fill = trans_docs)) +
  geom_bar(stat = "identity", position = "fill") +
  geom_text(aes(label = scales::percent(percentage, accuracy = 1)),  
            position = position_stack(vjust = 0.5), size = 4) + 
  scale_y_continuous(labels = percent_format()) + 
  scale_fill_manual(
    values = c("Yes" = "#2ECC71", "No" = "#E74C3C", "Don't Know" = "#3498DB")
  ) +
  labs(
    title = "Support for being able to change gender on official documents",
    x = "Gender",
    y = "Proportion of Responses",
    fill = ""
  ) +
  coord_flip() +  
  theme_minimal()+
  theme(
    panel.grid = element_blank(),
    axis.text.x = element_blank(),
    axis.ticks.x = element_blank()
  )
# Crear una tabla de contingencia
contingency_table <- table(data$gender, data$trans_docs)

# Realizar la prueba de chi-cuadrado
chisq_test <- chisq.test(contingency_table)
print(chisq_test)

    Pearson's Chi-squared test with Yates' continuity correction

data:  contingency_table
X-squared = 92.715, df = 1, p-value < 2.2e-16

Men exhibit a lower percentage of favorable or dk responses and a higher rate of rejection compared to women. There is a statistically significant association between gender and our target variable, being women more supportive

Age

data |> 
  mutate(trans_docs = fct_na_value_to_level(trans_docs, "Don't Know")) |>
  mutate(age_bin = cut(age, breaks = seq(min(age, na.rm = TRUE), max(age, na.rm = TRUE), by = 10), include.lowest = TRUE)) |> 
  # There are 4 observations above 95 y.o. that do not fall within any of the previously difined bins. Given their low number we drop them
  drop_na(age_bin) |> 
  count(age_bin, trans_docs) |> 
  group_by(age_bin) |> 
  mutate(percentage = n / sum(n) * 100) |>  
  ggplot(aes(x = age_bin, y = percentage, fill = trans_docs)) +
  geom_bar(stat = "identity", position = "stack") +
  coord_flip() +
  labs(x = "Age Bins", y = "Proportion of responses", fill = "",
       title = "Support for being able to change gender on official documents") +
  scale_fill_manual(
    values = c("Yes" = "#2ECC71", "No" = "#E74C3C", "Don't Know" = "#3498DB")
  ) +
  theme_minimal() +
   theme(
    panel.grid = element_blank(),
    axis.text.x = element_blank(),
    axis.ticks.x = element_blank()
  )

Younger people seem more likely to support the right for transgender people to have their gender changed on official documents.

We also notice a big increase of NAs for older people, meaning older people are less likely to respond to this question (because of unfamiliarity with the topic maybe)

So how would that distribution look if we get rid of NAs

data |> 
  drop_na(trans_docs) |> 
  mutate(age_bin = cut(age, breaks = seq(min(age, na.rm = TRUE), max(age, na.rm = TRUE), by = 10), include.lowest = TRUE)) |> 
  # There are 4 observations above 95 y.o. that do not fall within any of the previously difined bins. Given their low number we drop them
  drop_na(age_bin) |> 
  count(age_bin, trans_docs) |> 
  group_by(age_bin) |> 
  mutate(percentage = n / sum(n) * 100) |>  
  ggplot(aes(x = age_bin, y = percentage, fill = trans_docs)) +
  geom_bar(stat = "identity", position = "stack") +
  coord_flip() +
  labs(x = "Age Bins", y = "Proportion of responses", fill = "",
       title = "Support for being able to change gender on official documents") +
  scale_fill_manual(
    values = c("Yes" = "#2ECC71", "No" = "#E74C3C", "Don't Know" = "#3498DB")
  ) +
  theme_minimal() +
   theme(
    panel.grid = element_blank(),
    axis.text.x = element_blank(),
    axis.ticks.x = element_blank()
  )

We see that differences among age groups are not so evident anymore.

Religiosity

We have two variables related to religiosity: religion (the religious affiliation professed by the respondent) and religious_minority (whether or not the respondent belongs to a religious minority group).

For the first one it’s better to show a cross table instead of a plot, since there are a lot of categories

CrossTable(data$religion, data$trans_docs,
           digits = 2, 
           expected = FALSE, 
           asresid = TRUE, 
           chisq = TRUE, 
           prop.chisq = FALSE, 
           format = "SPSS")

   Cell Contents
|-------------------------|
|                   Count |
|             Row Percent |
|          Column Percent |
|           Total Percent |
|           Adj Std Resid |
|-------------------------|

Total Observations in Table:  23792 

                   | data$trans_docs 
     data$religion |      Yes  |       No  | Row Total | 
-------------------|-----------|-----------|-----------|
          Catholic |     5605  |     4241  |     9846  | 
                   |    56.93% |    43.07% |    41.38% | 
                   |    39.27% |    44.55% |           | 
                   |    23.56% |    17.83% |           | 
                   |    -8.09  |     8.09  |           | 
-------------------|-----------|-----------|-----------|
Orthodox Christian |     1421  |     1959  |     3380  | 
                   |    42.04% |    57.96% |    14.21% | 
                   |     9.96% |    20.58% |           | 
                   |     5.97% |     8.23% |           | 
                   |   -22.99  |    22.99  |           | 
-------------------|-----------|-----------|-----------|
        Protestant |     1866  |      807  |     2673  | 
                   |    69.81% |    30.19% |    11.23% | 
                   |    13.07% |     8.48% |           | 
                   |     7.84% |     3.39% |           | 
                   |    11.00  |   -11.00  |           | 
-------------------|-----------|-----------|-----------|
   Other Christian |      597  |      449  |     1046  | 
                   |    57.07% |    42.93% |     4.40% | 
                   |     4.18% |     4.72% |           | 
                   |     2.51% |     1.89% |           | 
                   |    -1.97  |     1.97  |           | 
-------------------|-----------|-----------|-----------|
             Other |      764  |      446  |     1210  | 
                   |    63.14% |    36.86% |     5.09% | 
                   |     5.35% |     4.68% |           | 
                   |     3.21% |     1.87% |           | 
                   |     2.30  |    -2.30  |           | 
-------------------|-----------|-----------|-----------|
            Muslim |      159  |      160  |      319  | 
                   |    49.84% |    50.16% |     1.34% | 
                   |     1.11% |     1.68% |           | 
                   |     0.67% |     0.67% |           | 
                   |    -3.72  |     3.72  |           | 
-------------------|-----------|-----------|-----------|
     Non-believers |     3860  |     1458  |     5318  | 
                   |    72.58% |    27.42% |    22.35% | 
                   |    27.05% |    15.32% |           | 
                   |    16.22% |     6.13% |           | 
                   |    21.28  |   -21.28  |           | 
-------------------|-----------|-----------|-----------|
      Column Total |    14272  |     9520  |    23792  | 
                   |    59.99% |    40.01% |           | 
-------------------|-----------|-----------|-----------|

 
Statistics for All Table Factors


Pearson's Chi-squared test 
------------------------------------------------------------
Chi^2 =  973.2956     d.f. =  6     p =  5.330102e-207 


 
       Minimum expected frequency: 127.6429 

Out of all observations Catholic, non-believers, Orthodox Christians and Protestants sum up to the 81.04% of our sample, being the rest underrepresented.

data_summary <- data |> 
  count(trans_docs, religious_minority, name = "n") |> 
  group_by(religious_minority) |>  
  mutate(percentage = n / sum(n))  

ggplot(data_summary, aes(x = trans_docs, y = percentage, fill = religious_minority)) +
  geom_bar(stat = "identity", position = "dodge") +  
  geom_text(aes(label = scales::percent(percentage, accuracy = 1)),  
            position = position_dodge(width = 0.9), vjust = -0.2, size = 4) +  
  scale_y_continuous(labels = percent_format()) + 
  labs(
    title = "Distribution of support by religious minority",
    x = "Support for trans people changing their civil documents",
    y = "Percentage within religious_minority",
    fill = "religious_minority"
  ) +
  theme_minimal()

Ideology

data_summary <- data |> 
  count(trans_docs, left_right, name = "n") |> 
  group_by(left_right) |>  
  mutate(percentage = n / sum(n))  

ggplot(data_summary, aes(x = trans_docs, y = percentage, fill = left_right)) +
  geom_bar(stat = "identity", position = "dodge") +  
  geom_text(aes(label = scales::percent(percentage, accuracy = 1)),  
            position = position_dodge(width = 0.9), vjust = -0.2, size = 4) +  
  scale_y_continuous(labels = percent_format()) + 
  labs(
    title = "Distribution of support by ideology",
    x = "Support for trans people changing their civil documents",
    y = "Percentage within ideology",
    fill = "ideology"
  ) +
  theme_minimal()

Stronger left-wing support for trans rights. Right-wing respondents are the most divided, with high opposition levels. Non-responses are highest among those without ideological alignment.

Social class

data_summary <- data |> 
  count(trans_docs, social_class, name = "n") |> 
  group_by(social_class) |>  
  mutate(percentage = n / sum(n))  

ggplot(data_summary, aes(x = trans_docs, y = percentage, fill = social_class)) +
  geom_bar(stat = "identity", position = "dodge") +  
  geom_text(aes(label = scales::percent(percentage, accuracy = 1)),  
            position = position_dodge(width = 0.9), vjust = -0.2, size = 4) +  
  scale_y_continuous(labels = percent_format()) + 
  labs(
    title = "Distribution of support by social class",
    x = "Support for trans people changing their civil documents",
    y = "Percentage within social class",
    fill = "social class"
  ) +
  theme_minimal()

Although D63 of the questionnaire measures (oneself’s and one’s household’s) self-perceived social class, it is still a relevant and seemingly divisive variable. We observe a positive correlation, where support grows with increasing (perceived) social class, while explicit lack of support and no response are higher for lower-class individuals.

Education

ggplot(data, aes(x = trans_docs, y = years_edu)) +
  geom_violin() +
  labs(x = "Support for trans people changing their civil documents", y = "Age when stopped full-time education") +
  ggtitle("Distribution of support by education")

Support doesn’t seem to be related to education.

Area of residence

data_summary <- data |> 
  count(trans_docs, community, name = "n") |> 
  group_by(community) |>  
  mutate(percentage = n / sum(n))  

ggplot(data_summary, aes(x = trans_docs, y = percentage, fill = community)) +
  geom_bar(stat = "identity", position = "dodge") +  
  geom_text(aes(label = scales::percent(percentage, accuracy = 1)),  
            position = position_dodge(width = 0.9), vjust = -0.2, size = 4) +  
  scale_y_continuous(labels = percent_format()) + 
  labs(
    title = "Distribution of support by area of residence",
    x = "Support for trans people changing their civil documents",
    y = "Percentage within area of residence",
    fill = "area of residence"
  ) +
  theme_minimal()

Support does not vary much by area of residence.

Other individual-level variables

Having trans friends

data_summary <- data |> 
  count(trans_docs, friends_trans, name = "n") |> 
  group_by(friends_trans) |>  
  mutate(percentage = n / sum(n))  

ggplot(data_summary, aes(x = trans_docs, y = percentage, fill = friends_trans)) +
  geom_bar(stat = "identity", position = "dodge") +  
  geom_text(aes(label = scales::percent(percentage, accuracy = 1)),  
            position = position_dodge(width = 0.9), vjust = -0.2, size = 4) +  
  scale_y_continuous(labels = percent_format()) + 
  labs(
    title = "Distribution of support by haivng trans friends",
    x = "Support for trans people changing their civil documents",
    y = "Percentage within groups",
    fill = "Has Trans Friends"
  ) +
  theme_minimal()

Having trans friends is associated with a higher support, while those who refuse to disclose their connections to trans people tend to oppose more.

Country-level EDA

Replication of the plot in Marga’s document. This is probably not needed in the final version of the document.

country_support <- data %>%
  mutate(
    trans_docs = case_when(
      is.na(trans_docs) ~ "DK",
      trans_docs == "Yes" ~ "1",
      trans_docs == "No" ~ "2",
      TRUE ~ as.character(trans_docs)
    )
  ) %>%
  group_by(country, trans_docs = trans_docs) %>%
  summarise(count = n(), .groups = "drop") %>%
  group_by(country) %>%
  mutate(proportion = (count / sum(count))*100) %>%
  ungroup()

ggplot(country_support, aes(x = factor(country, levels = country_support %>%
                                       filter(trans_docs == "1") %>%
                                       arrange(desc(proportion)) %>%
                                       pull(country)), 
                           y = proportion,
                           fill = factor(trans_docs, levels = c("1", "2", "DK")))) +
  geom_bar(stat = "identity", position = position_stack(reverse = TRUE)) +
  scale_fill_manual(values = c("1" = "#497ba9", "2" = "#d56e6e", "DK" = "#9a9595"),
                   name = "",
                   labels = c("Yes", "No", "Don't know")) +
  geom_text(aes(label = round(proportion)), 
          position = position_stack(reverse = TRUE, vjust = 0.5),
          size = 3.5, color = "white") +
  labs(
    title = "QC9: Do you think transgender persons should be able to change their civil documents to match their inner gender identity?",
    x = "", 
    y = ""
  ) +
  theme_minimal() +
  theme(axis.text.x = element_text(angle = 45, hjust = 1),
        axis.text.y = element_blank(),
        axis.ticks.y = element_blank(),
        plot.title = element_text(size = 9),
        panel.grid.major.y = element_blank(),
        legend.position = "bottom")

There are some mismatches, I guess the data might have become distorted at some point during processing, but I don’t know when.

trans_docs_prop <- country_support %>%
  filter(trans_docs == "1") %>%
  select(country, proportion) %>%
  rename(trans_support = proportion)

country_long <- country_level_data %>%
  inner_join(trans_docs_prop, by = c("iso2c" = "country")) |> 
  pivot_longer(cols = c(gdp_pc_ppp, gender_inequality_index, lgbt_policy_index, democracy_index),
    names_to = "variable", values_to = "value")

ggplot(country_long, aes(x = value, y = trans_support)) +
  geom_smooth(method = "lm", se = FALSE, color = "lightgray") + # we can remove this
  geom_point(size = 2, color = "blue", alpha = 0.7) +
  geom_text(aes(label = iso3c), vjust = -0.5, hjust = 0.5, size = 3) +
  facet_wrap(~variable, scales = "free_x") +
  labs(
    title = "Relationship between country-level variables and trans support",
    x = "Country-level variable",
    y = "Proportion of Yes answers"
  ) +
  theme_minimal()

Democracy and LGBT Policy indeces seem to have a positive linear relationship with the target variable, while Gender Inequality index has a negative linear relationship. The relationship with GDP per capita is non-linear (logarithmic?). There appears to be a “ceiling” of support, beyond which increases in GDP per capita lose effect.

Boxplots for country-level variables:

ggplot(country_long, aes(y = value, x = variable)) +
  geom_boxplot(outlier.color = "red", outlier.shape = 16, fill = "lightblue") +
  coord_flip() +
  theme_minimal() +
  labs(title = "Distribution of country-level variables", x = NULL, y = "value") +
  facet_wrap(~variable, scales = "free") +
  theme(axis.text.y = element_blank(),  
        axis.ticks.x = element_blank())

country_level_data_cor <- country_level_data %>%
  inner_join(trans_docs_prop, by = c("iso2c" = "country"))

cor_matrix <- cor(country_level_data_cor %>%
                    select(gdp_pc_ppp, democracy_index, gender_inequality_index, 
                           lgbt_policy_index, trans_support),
                  use = "complete.obs")

corrplot(cor_matrix, method = "color", type = "upper", 
         addCoef.col = "black", tl.col = "black",
         col = colorRampPalette(c("blue", "white", "red"))(200))

Some heavy correlations which is a little worrying, but as we are going to use these data to build cross-level interactions, this should not compromise the reliability of our analysis too much.

Paradata

# Extracting labels in paradata
list_label_tibbles_paradata <- lapply(names(paradata), function(col_name) {
  labels <- attr(paradata[[col_name]], "labels")  
  name_labels <- names(labels)  
  if (!is.null(labels)) {
    tibble(name_labels = name_labels, labels = labels)
  } else {
    NULL
  }
})

# Asign names to list elements
list_label_tibbles_paradata <- setNames(list_label_tibbles_paradata, names(paradata))

# Convert into factor
paradata <- paradata %>%
  mutate(across(where(~ !is.null(attr(., "labels"))), labelled::to_factor))

# Merging datasets for the analysis
merged_paradata <- merge(data, paradata, by = "serialid", all.x = TRUE)

Number of persons present during interview:

library(gmodels)

# Convert NA in a explicit category
merged_paradata$trans_docs <- as.character(merged_paradata$trans_docs)   
merged_paradata$trans_docs[is.na(merged_paradata$trans_docs)] <- "DK"  
merged_paradata$trans_docs <- as.factor(merged_paradata$trans_docs)  

# CrossTable
CrossTable(merged_paradata$p4, merged_paradata$trans_docs,
           digits=2, 
           expected=F, 
           asresid=T, 
           chisq=TRUE, 
           prop.chisq=F, 
           format="SPSS")

   Cell Contents
|-------------------------|
|                   Count |
|             Row Percent |
|          Column Percent |
|           Total Percent |
|           Adj Std Resid |
|-------------------------|

Total Observations in Table:  27438 

                                 | merged_paradata$trans_docs 
              merged_paradata$p4 |       DK  |       No  |      Yes  | Row Total | 
---------------------------------|-----------|-----------|-----------|-----------|
Two (interviewer and respondent) |     2806  |     8146  |    12428  |    23380  | 
                                 |    12.00% |    34.84% |    53.16% |    85.21% | 
                                 |    85.55% |    84.02% |    85.93% |           | 
                                 |    10.23% |    29.69% |    45.29% |           | 
                                 |     0.58  |    -4.10  |     3.54  |           | 
---------------------------------|-----------|-----------|-----------|-----------|
                           Three |      428  |     1316  |     1758  |     3502  | 
                                 |    12.22% |    37.58% |    50.20% |    12.76% | 
                                 |    13.05% |    13.57% |    12.16% |           | 
                                 |     1.56% |     4.80% |     6.41% |           | 
                                 |     0.52  |     2.97  |    -3.19  |           | 
---------------------------------|-----------|-----------|-----------|-----------|
                            Four |       36  |      189  |      218  |      443  | 
                                 |     8.13% |    42.66% |    49.21% |     1.61% | 
                                 |     1.10% |     1.95% |     1.51% |           | 
                                 |     0.13% |     0.69% |     0.79% |           | 
                                 |    -2.50  |     3.25  |    -1.49  |           | 
---------------------------------|-----------|-----------|-----------|-----------|
                    Five or more |       10  |       44  |       59  |      113  | 
                                 |     8.85% |    38.94% |    52.21% |     0.41% | 
                                 |     0.30% |     0.45% |     0.41% |           | 
                                 |     0.04% |     0.16% |     0.22% |           | 
                                 |    -1.02  |     0.80  |    -0.11  |           | 
---------------------------------|-----------|-----------|-----------|-----------|
                    Column Total |     3280  |     9695  |    14463  |    27438  | 
                                 |    11.95% |    35.33% |    52.71% |           | 
---------------------------------|-----------|-----------|-----------|-----------|

 
Statistics for All Table Factors


Pearson's Chi-squared test 
------------------------------------------------------------
Chi^2 =  26.44717     d.f. =  6     p =  0.0001837381 


 
       Minimum expected frequency: 13.50827 

The table shows a significant association between the number of people present during the interview and support for transgender people to change their documents

Regarding the duration of the interview we have 2 options p3 and p3r. We will use p3r to have a simpler analysis

# CrossTable
CrossTable(merged_paradata$p3r, merged_paradata$trans_docs,
           digits=2, 
           expected=F, 
           asresid=T, 
           chisq=TRUE, 
           prop.chisq=F, 
           format="SPSS")

   Cell Contents
|-------------------------|
|                   Count |
|             Row Percent |
|          Column Percent |
|           Total Percent |
|           Adj Std Resid |
|-------------------------|

Total Observations in Table:  27438 

                    | merged_paradata$trans_docs 
merged_paradata$p3r |       DK  |       No  |      Yes  | Row Total | 
--------------------|-----------|-----------|-----------|-----------|
   Up to 14 minutes |       73  |      224  |      260  |      557  | 
                    |    13.11% |    40.22% |    46.68% |     2.03% | 
                    |     2.23% |     2.31% |     1.80% |           | 
                    |     0.27% |     0.82% |     0.95% |           | 
                    |     0.85  |     2.43  |    -2.88  |           | 
--------------------|-----------|-----------|-----------|-----------|
    15 - 29 minutes |      782  |     2284  |     3456  |     6522  | 
                    |    11.99% |    35.02% |    52.99% |    23.77% | 
                    |    23.84% |    23.56% |    23.90% |           | 
                    |     2.85% |     8.32% |    12.60% |           | 
                    |     0.10  |    -0.61  |     0.52  |           | 
--------------------|-----------|-----------|-----------|-----------|
    30 - 44 minutes |     1429  |     4388  |     6305  |    12122  | 
                    |    11.79% |    36.20% |    52.01% |    44.18% | 
                    |    43.57% |    45.26% |    43.59% |           | 
                    |     5.21% |    15.99% |    22.98% |           | 
                    |    -0.75  |     2.66  |    -2.06  |           | 
--------------------|-----------|-----------|-----------|-----------|
    45 - 59 minutes |      703  |     1993  |     3039  |     5735  | 
                    |    12.26% |    34.75% |    52.99% |    20.90% | 
                    |    21.43% |    20.56% |    21.01% |           | 
                    |     2.56% |     7.26% |    11.08% |           | 
                    |     0.80  |    -1.04  |     0.48  |           | 
--------------------|-----------|-----------|-----------|-----------|
    60 - 74 minutes |      202  |      529  |      908  |     1639  | 
                    |    12.32% |    32.28% |    55.40% |     5.97% | 
                    |     6.16% |     5.46% |     6.28% |           | 
                    |     0.74% |     1.93% |     3.31% |           | 
                    |     0.48  |    -2.67  |     2.25  |           | 
--------------------|-----------|-----------|-----------|-----------|
    75 - 89 minutes |       49  |      123  |      276  |      448  | 
                    |    10.94% |    27.46% |    61.61% |     1.63% | 
                    |     1.49% |     1.27% |     1.91% |           | 
                    |     0.18% |     0.45% |     1.01% |           | 
                    |    -0.67  |    -3.52  |     3.80  |           | 
--------------------|-----------|-----------|-----------|-----------|
90 minutes and more |       42  |      154  |      219  |      415  | 
                    |    10.12% |    37.11% |    52.77% |     1.51% | 
                    |     1.28% |     1.59% |     1.51% |           | 
                    |     0.15% |     0.56% |     0.80% |           | 
                    |    -1.16  |     0.76  |     0.02  |           | 
--------------------|-----------|-----------|-----------|-----------|
       Column Total |     3280  |     9695  |    14463  |    27438  | 
                    |    11.95% |    35.33% |    52.71% |           | 
--------------------|-----------|-----------|-----------|-----------|

 
Statistics for All Table Factors


Pearson's Chi-squared test 
------------------------------------------------------------
Chi^2 =  36.84302     d.f. =  12     p =  0.0002368813 


 
       Minimum expected frequency: 49.61003 

Respondent cooperation

data_summary <- merged_paradata |> 
  count(p5, trans_docs, name = "n") |> 
  group_by(p5) |>  
  mutate(percentage = n / sum(n))  

ggplot(data_summary, aes(x = p5, y = percentage, fill = trans_docs)) +
  geom_bar(stat = "identity", position = "dodge") +  
  geom_text(aes(label = scales::percent(percentage, accuracy = 1)),  
            position = position_dodge(width = 0.9), vjust = -0.2, size = 4) +  
  scale_y_continuous(labels = percent_format()) + 
  labs(
    title = "Distribution of support by Respondent cooperation",
    x = "Respondent cooperation",
    y = "Percentage within groups",
    fill = "Support"
  ) +
  theme_minimal()
# Calcular porcentajes
plot_data <- merged_paradata %>%
  group_by(p5, trans_docs) %>%
  summarise(count = n(), .groups = 'drop') %>%
  mutate(percentage = count / sum(count) * 100)

Respondents who engaged better in the survey were more likely to express support.

Correlation and multicollinearity

Now we want to take a look at the possible multicollinearity of our explanatory variables. For it, we calculate the correlation of our numerical variables. As we have too many variables, we visualize just those with a strong correlation to focus on key dependencies.

cor_matrix <- cor(data %>%
                    select_if(is.numeric) %>%
                    select(-serialid),
                  use = "complete.obs")

corrplot(cor_matrix, method = "color", type = "upper", 
         tl.col = "black",
         col = colorRampPalette(c("blue", "white", "red"))(200))
# Create a matrix where only correlations >= 0.7 are maintained
cor_filtered <- ifelse(abs(cor_matrix) >= 0.7, cor_matrix, NA)

# Graph
corrplot(cor_filtered, method = "color", type = "upper", 
         tl.col = "black", 
         col = colorRampPalette(c("blue", "white", "red"))(200),
         na.label = " ",
         insig = "blank") 

Most strong correlations are among variables related to race, religion or sexual orientation discrimination. Consequently, we are grouping them into 3 new composite variables by averaging related ones, in order to reduce multicollinearity.

# Creating grouped variables
data <- data %>%
  mutate(
    racial_discri = rowMeans(select(., roma_discri, black_discri, asian_discri), na.rm = TRUE), #no white
    sexual_discri = rowMeans(select(., lgb_discri, trans_discri, intersex_discri), na.rm = TRUE),
    religious_discri = rowMeans(select(., jewish_discri, muslim_discri, buddihst_discri), na.rm = TRUE)
  ) 

# Removing original variables to avoid redundancy
data <- data |> 
  select(-c(roma_discri, black_discri, asian_discri, lgb_discri, trans_discri, intersex_discri, jewish_discri, muslim_discri, buddihst_discri))


# Graphical representation
cor_matrix <- cor(data %>%
                    select_if(is.numeric) %>%
                    select(-serialid),
                  use = "complete.obs")


corrplot(cor_matrix, method = "color", type = "upper", 
         tl.col = "black",
         col = colorRampPalette(c("blue", "white", "red"))(200))

We realize our new variables are still highly correlated between them. For reducing the dimensionality of the dataset even more while preserving information we create one single variable for general minority discrimination.

# Creating grouped variable
data <- data %>%
  mutate(
    minority_discri = rowMeans(select(., racial_discri, sexual_discri, religious_discri, disability_discri), na.rm = TRUE)) 

We decided to exclude white_discri, atheist_discri, christian_discri because we realized they had a median of 1 and a quite small mean, meaning there is almost no reported discrimination against these groups in the dataset.

summary(data$white_discri)
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max.    NA's 
  1.000   1.000   1.000   1.785   2.000  10.000     403 
summary(data$atheist_discri)
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max.    NA's 
  1.000   1.000   1.500   2.802   4.000  10.000     517 
summary(data$christian_discri)
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max.    NA's 
  1.000   1.000   1.000   1.904   2.000  10.000     414 
data <- data |> 
  select(-c(white_discri, atheist_discri, christian_discri, racial_discri, sexual_discri, religious_discri, disability_discri))

Final check of the correlation matrix to confirm that multicollinearity has been reduced.

cor_matrix <- cor(data %>%
                    select_if(is.numeric) %>%
                    select(-serialid),
                  use = "complete.obs")


corrplot(cor_matrix, method = "color", type = "upper", 
         addCoef.col = "black", tl.col = "black",
         col = colorRampPalette(c("blue", "white", "red"))(200))

Class imbalance

prop.table(table(data$trans_docs, useNA = "ifany"))

      Yes        No      <NA> 
0.5271157 0.3533421 0.1195422 
prop.table(table(data$trans_docs, useNA = "no"))

      Yes        No 
0.5986837 0.4013163 

Our target variable has a 60/40 distribution so we are not worried about class imbalance.

Less represented classes in other variables have already been aggregated if deemed necessary.

Analysis of missing values

Here we analyse the NA reponses to our target variable. This is a sort of robustness check to understand our data and learn if there are patterns in NA response that we should be worried about e.g. if there are specific demographics of people who are less likely to respond.

Overall the analysis below shows that non response is similar to the descriptive data and aligned with some groups reported “No” to supporting trans_docs in c19. So we’re more at risk of underreporting “no” votes in this survey due to non-response. The correlation is low though so it’s not a major concern.

Who is more likely to not respond to our target?

There are 3,280 NA responses to the target variable. To try understand if the missing values are at random, we will test the correlation between NA response and Use the DK (don’t know) for our target variable.

In the descriptive analysis above, we have already seen in raw terms that NA responses were more frequent from some groups e.g.

Create a binary variable for the DK

cntry_name <- codelist |> select(iso2c, country_name = country.name.en)
dk_target <- data |> 
  mutate(target_NA = ifelse(is.na(trans_docs), 1, 0)) |> 
  left_join(cntry_name, by = join_by(country == iso2c)) |> 
  dplyr::select(-trans_docs, -serialid, -country)

table(dk_target$target_NA)

    0     1 
24158  3280 

Confirm DK rates by country. They vary from 1.4% in Belgium to 28.5% in Bulgaria. Overall, the average is 11.95%.

dk_target |> 
  group_by(country_name) |> 
  summarise(count_na = sum(target_NA),
            num_resp = length(country_name),
            pct_na = count_na/num_resp*100) |> 
  ggplot(aes(x=reorder(country_name, -pct_na), y = pct_na))+
  geom_col()+
  theme(axis.text.x = element_text(angle = 45, hjust = 1),
        axis.title.x = element_blank()) +
  scale_y_continuous(labels = scales::percent_format(scale = 1)) + 
  labs(y = "Proportion of NA responses")

If all NA responses to the target are removed, this is how much the “Yes” count increases for each of our countries. We see this is not proportional. This is a statistical phenomenon. distribution of the variable looks by country. The NA vote removal, makes our differences in Yes/No differences appear larger.

data |> 
  group_by(country) |> 
  summarise(yes_count = sum(trans_docs == "Yes", na.rm=TRUE),
            num_resp = sum(!is.na(trans_docs)),
            num_na = sum(is.na(trans_docs)),
            pct_yes_withna = yes_count / length(country)*100,
            pct_yes = yes_count/num_resp*100)|> 
  ggplot(aes(x = reorder(country, -pct_yes))) +
  geom_col(aes(y = pct_yes), fill = "red") + # First bar (pct_yes)
  geom_col(aes(y = pct_yes_withna), fill = "yellow", alpha = 0.5) + # Second bar (pct_yes_withna)
  theme(axis.text.x = element_text(angle = 45, hjust = 1),
        axis.title.x = element_blank()) +
  scale_y_continuous(labels = scales::percent_format(scale = 1),
                     limits = c(0,100)) + 
  labs(title ="Support for transgender rights to legally change documents, with and without NA's")

Check correlation with DK of target

Run model to test what is correlated with DK response, use Cramers V for association between the factor variables and correlation for the numeric variables in the cleaned data.

  1. Model the data for DK responses against the factor variables.
factor_subset <- dk_target %>%
  dplyr::select(target_NA, where(is.factor)) |> 
  mutate(target_NA = factor(target_NA))

# Run cramers V for factors

target_var <- "target_NA"
factor_variables <- names(factor_subset)
factor_variables <- factor_variables[factor_variables != target_var]

cramers_v_results <- list()

for (variable in factor_variables) {
    contingency_table <- table(factor_subset[[target_var]], 
                               factor_subset[[variable]])
    cramers_v <- CramerV(contingency_table)
    cramers_v_results[[variable]] <- cramers_v
}

# Create a Tibble for Results
cat_results <- tibble(variable = names(cramers_v_results),
       cramers_v = unlist(cramers_v_results)) |> 
  arrange(desc(cramers_v))
cat_results
# A tibble: 22 × 2
   variable       cramers_v
   <chr>              <dbl>
 1 internet_use      0.136 
 2 social_class      0.0975
 3 occupation        0.0852
 4 marital_status    0.0831
 5 gender_docs       0.0820
 6 religion          0.0763
 7 phone_access      0.0711
 8 life_sat          0.0642
 9 polintr           0.0621
10 friends_trans     0.0581
# ℹ 12 more rows

This shows all of the factors have quite low association with the NA responses. The highest being internet use. This is a good sign that the missing values are random.

  1. Look at the numeric variables and test correlations:
numeric_subset <- dk_target %>%
  dplyr::select(target_NA, where(is.numeric)) 

target_var <- "target_NA"
numeric_variables <- names(numeric_subset)[names(numeric_subset) != target_var]

cor_results <- list()

for (variable in numeric_variables) {
    correlation <- cor(numeric_subset$target_NA, 
                       numeric_subset[[variable]],
                       use = "pairwise.complete.obs")
    cor_results[[variable]] <- correlation
}

# Create a Tibble for Results
cor_results <- tibble(variable = names(cor_results),
       cor = unlist(cor_results)) |> 
  arrange(cor)
cor_results
# A tibble: 7 × 2
  variable                     cor
  <chr>                      <dbl>
1 n_actions_against_discri -0.0988
2 n_friends_minorities     -0.0965
3 years_edu                -0.0544
4 social_alienation         0.0566
5 minority_discri           0.0635
6 age                       0.0982
7 antilgbtq_rights          0.108 

Again, this is not too much cause for concern. We only have around 10% correlations, positive and negative with the target variable.

Modelling relationship with key variables and non-response

Here we run a logistic regression to test for the most important/significant variables. First, we make a subset of data with only our variables that were most correlated in the seciton above (use above +/- 9.5% correlation and above 10% cramers V) and also include gender and country.

cor_results |> filter(cor > 0.09 | cor < -0.9) |> pull(variable)
[1] "age"              "antilgbtq_rights"
cat_results |> filter(cramers_v >0.1) |> pull(variable)
[1] "internet_use"

Now model with those variables to see if they are significant in explaining the DK values. Gender will also be included as a key variable.

We run a stepwise AIC on these most correlated variables and then use the best model to test the overall model fit.

# first, run stepwise to determine most important 
# run base model 
dk_fit_null <- glm(target_NA ~ 1,
              data = dk_target, 
              family = "binomial")
# run full fit model of most correlated vars with country (also age^2 for good practice)
dk_fit <- glm(target_NA ~ gender + age + I(age*age) + antilgbtq_rights + internet_use + social_class + country_name, 
              data = dk_target, 
              family = "binomial")

# use stepwise to select best mode l
aic_1 <- MASS::stepAIC(dk_fit, scope = list(upper = dk_fit, 
                             lower = dk_fit_null),
        direction = "both", k = 2, trace=0) # forward based on AIC

# filter vars significant at 5% and calculate exponential
broom::tidy(aic_1) |> 
  filter(p.value<0.05) |> 
  mutate(oddsratio = exp(estimate)) |> 
  select(term, oddsratio, p.value)
# A tibble: 29 × 3
   term                                          oddsratio  p.value
   <chr>                                             <dbl>    <dbl>
 1 (Intercept)                                      0.0500 8.78e-40
 2 genderWoman                                      1.20   2.01e- 5
 3 I(age * age)                                     1.00   4.77e- 4
 4 antilgbtq_rights                                 1.13   9.69e- 7
 5 internet_useTwo or three times a week            1.21   2.72e- 2
 6 internet_useTwo or three times a month           0.307  4.97e- 3
 7 internet_useNever/No access                      1.28   2.49e- 4
 8 internet_useNo Internet access at all            1.57   4.62e- 4
 9 social_classThe lower middle class of society    0.766  4.62e- 5
10 social_classThe middle class of society          0.713  4.09e-11
# ℹ 19 more rows

The best model is the one without age but includes age^2. So we run the full model to keep the lower level variables included.

The model has some interesting findings to who did not respond to our findings. Some things we can see with the odds ratios (excluding interpretation of countries as that is covered above):


Below is an option using undersampling which is probably more legit too.

# split to test and training
na_model <- glm(target_NA ~ .,
                      data = dk_target, 
                      family = "binomial")
summary(na_model)

Call:
glm(formula = target_NA ~ ., family = "binomial", data = dk_target)

Coefficients:
                                                      Estimate
(Intercept)                                          -5.096435
age                                                   0.012178
genderWoman                                           0.164789
years_edu                                            -0.005912
communitySmall or middle sized town                   0.060070
communityLarge town                                  -0.083705
marital_statusSingle living with partner (5-8 in d7) -0.229059
marital_statusSingle (9-10 in d7)                    -0.151896
marital_statusDivorced or separated (11-12 in d7)     0.289686
marital_statusWidow (13-14 in d7)                     0.216811
occupationManagers (10 to 12 in d15a)                 0.074469
occupationOther white collars (13 or 14 in d15a)     -0.002162
occupationManual workers (15 to 18 in d15a)          -0.087856
occupationHouse persons (1 in d15a)                  -0.244480
occupationUnemployed (3 in d15a)                      0.032945
occupationRetired (4 in d15a)                        -0.152771
occupationStudents (2 in d15a)                       -0.516985
social_classThe lower middle class of society        -0.191067
social_classThe middle class of society              -0.102517
social_classThe upper middle class of society        -0.048871
social_classThe higher class of society               0.028047
religionOrthodox Christian                           -0.272443
religionProtestant                                    0.161109
religionOther Christian                              -0.132124
religionOther                                        -0.791153
religionMuslim                                        0.691685
religionNon-believers                                -0.020914
nonEU_national1                                      -0.370848
phone_accessLandline only                            -0.110733
phone_accessLandline & mobile                         0.039715
phone_accessNo telephone                             -0.500657
bill_issuesFrom time to time                          0.232590
bill_issuesAlmost never/never                         0.457448
internet_useTwo or three times a week                 0.184435
internet_useAbout once a week                         0.437365
internet_useTwo or three times a month               -1.580741
internet_useLess often                                0.079182
internet_useNever/No access                           0.290840
internet_useNo Internet access at all                 0.312489
life_satFairly satisfied                              0.053242
life_satNot very satisfied                            0.291434
life_satNot at all satisfied                          0.005602
polintrMedium                                         0.080670
polintrLow                                            0.126350
polintrNot at all                                    -0.045332
left_right(5 - 6) Centre                              0.122380
left_right(7 -10) Right                               0.094612
social_alienation                                     0.124139
ethnic_minority1                                      0.461184
skincolor_minority1                                  -0.927202
religious_minority1                                  -0.483626
roma_minority1                                       -0.234027
sexual_minority1                                     -0.429264
disability_minority1                                  0.278993
suffered_discr1                                      -0.380922
gender_docsNo                                         0.536267
friends_transNo                                      -0.075223
friends_transRefusal (SPONTANEOUS)                    0.147667
n_friends_minorities                                  0.037060
n_actions_against_discri                             -0.150414
antilgbtq_rights                                      0.055886
minority_discri                                      -0.028983
country_nameBelgium                                  -1.057217
country_nameBulgaria                                  1.258296
country_nameCroatia                                  -0.006931
country_nameCyprus                                    0.618536
country_nameCzechia                                   0.063576
country_nameDenmark                                   0.020749
country_nameEstonia                                   0.498044
country_nameFinland                                   0.506632
country_nameFrance                                    0.209453
country_nameGermany                                   0.551572
country_nameGreece                                    0.155828
country_nameHungary                                  -0.199701
country_nameIreland                                   0.042946
country_nameItaly                                     0.258879
country_nameLatvia                                    0.686826
country_nameLithuania                                 0.118117
country_nameLuxembourg                               -0.023112
country_nameMalta                                    -0.619311
country_nameNetherlands                              -0.325966
country_namePoland                                    0.501405
country_namePortugal                                 -0.339504
country_nameRomania                                  -0.023516
country_nameSlovakia                                  0.249307
country_nameSlovenia                                  0.151497
country_nameSpain                                    -0.389991
country_nameSweden                                    0.821909
country_nameUnited Kingdom                            0.544943
                                                     Std. Error
(Intercept)                                            0.505490
age                                                    0.004217
genderWoman                                            0.082464
years_edu                                              0.007160
communitySmall or middle sized town                    0.095266
communityLarge town                                    0.106848
marital_statusSingle living with partner (5-8 in d7)   0.153178
marital_statusSingle (9-10 in d7)                      0.148656
marital_statusDivorced or separated (11-12 in d7)      0.129040
marital_statusWidow (13-14 in d7)                      0.125780
occupationManagers (10 to 12 in d15a)                  0.188675
occupationOther white collars (13 or 14 in d15a)       0.186434
occupationManual workers (15 to 18 in d15a)            0.174101
occupationHouse persons (1 in d15a)                    0.263347
occupationUnemployed (3 in d15a)                       0.250771
occupationRetired (4 in d15a)                          0.176731
occupationStudents (2 in d15a)                         0.364050
social_classThe lower middle class of society          0.127529
social_classThe middle class of society                0.102911
social_classThe upper middle class of society          0.182548
social_classThe higher class of society                0.527417
religionOrthodox Christian                             0.208576
religionProtestant                                     0.154425
religionOther Christian                                0.206172
religionOther                                          0.279671
religionMuslim                                         0.325376
religionNon-believers                                  0.130285
nonEU_national1                                        1.018180
phone_accessLandline only                              0.229728
phone_accessLandline & mobile                          0.100780
phone_accessNo telephone                               0.355297
bill_issuesFrom time to time                           0.188589
bill_issuesAlmost never/never                          0.188085
internet_useTwo or three times a week                  0.156891
internet_useAbout once a week                          0.257105
internet_useTwo or three times a month                 1.011667
internet_useLess often                                 0.337876
internet_useNever/No access                            0.128823
internet_useNo Internet access at all                  0.268088
life_satFairly satisfied                               0.101376
life_satNot very satisfied                             0.144484
life_satNot at all satisfied                           0.247800
polintrMedium                                          0.107402
polintrLow                                             0.136224
polintrNot at all                                      0.151273
left_right(5 - 6) Centre                               0.097494
left_right(7 -10) Right                                0.105449
social_alienation                                      0.048298
ethnic_minority1                                       0.233612
skincolor_minority1                                    0.522311
religious_minority1                                    0.269626
roma_minority1                                         0.404566
sexual_minority1                                       0.520931
disability_minority1                                   0.250759
suffered_discr1                                        0.137183
gender_docsNo                                          0.092952
friends_transNo                                        0.151250
friends_transRefusal (SPONTANEOUS)                     0.397164
n_friends_minorities                                   0.024872
n_actions_against_discri                               0.064844
antilgbtq_rights                                       0.052789
minority_discri                                        0.022540
country_nameBelgium                                    0.426007
country_nameBulgaria                                   0.346358
country_nameCroatia                                    0.341891
country_nameCyprus                                     0.449668
country_nameCzechia                                    0.328735
country_nameDenmark                                    0.350265
country_nameEstonia                                    0.333545
country_nameFinland                                    0.328111
country_nameFrance                                     0.338444
country_nameGermany                                    0.302573
country_nameGreece                                     0.405321
country_nameHungary                                    0.337837
country_nameIreland                                    0.348477
country_nameItaly                                      0.342212
country_nameLatvia                                     0.320758
country_nameLithuania                                  0.329320
country_nameLuxembourg                                 0.449294
country_nameMalta                                      0.644793
country_nameNetherlands                                0.367757
country_namePoland                                     0.326395
country_namePortugal                                   0.391052
country_nameRomania                                    0.400689
country_nameSlovakia                                   0.319901
country_nameSlovenia                                   0.338876
country_nameSpain                                      0.392042
country_nameSweden                                     0.320433
country_nameUnited Kingdom                             0.329095
                                                     z value Pr(>|z|)
(Intercept)                                          -10.082  < 2e-16
age                                                    2.888  0.00388
genderWoman                                            1.998  0.04568
years_edu                                             -0.826  0.40898
communitySmall or middle sized town                    0.631  0.52833
communityLarge town                                   -0.783  0.43339
marital_statusSingle living with partner (5-8 in d7)  -1.495  0.13481
marital_statusSingle (9-10 in d7)                     -1.022  0.30688
marital_statusDivorced or separated (11-12 in d7)      2.245  0.02477
marital_statusWidow (13-14 in d7)                      1.724  0.08476
occupationManagers (10 to 12 in d15a)                  0.395  0.69307
occupationOther white collars (13 or 14 in d15a)      -0.012  0.99075
occupationManual workers (15 to 18 in d15a)           -0.505  0.61382
occupationHouse persons (1 in d15a)                   -0.928  0.35322
occupationUnemployed (3 in d15a)                       0.131  0.89548
occupationRetired (4 in d15a)                         -0.864  0.38736
occupationStudents (2 in d15a)                        -1.420  0.15558
social_classThe lower middle class of society         -1.498  0.13407
social_classThe middle class of society               -0.996  0.31917
social_classThe upper middle class of society         -0.268  0.78892
social_classThe higher class of society                0.053  0.95759
religionOrthodox Christian                            -1.306  0.19148
religionProtestant                                     1.043  0.29682
religionOther Christian                               -0.641  0.52162
religionOther                                         -2.829  0.00467
religionMuslim                                         2.126  0.03352
religionNon-believers                                 -0.161  0.87247
nonEU_national1                                       -0.364  0.71569
phone_accessLandline only                             -0.482  0.62979
phone_accessLandline & mobile                          0.394  0.69353
phone_accessNo telephone                              -1.409  0.15880
bill_issuesFrom time to time                           1.233  0.21746
bill_issuesAlmost never/never                          2.432  0.01501
internet_useTwo or three times a week                  1.176  0.23977
internet_useAbout once a week                          1.701  0.08892
internet_useTwo or three times a month                -1.563  0.11817
internet_useLess often                                 0.234  0.81471
internet_useNever/No access                            2.258  0.02397
internet_useNo Internet access at all                  1.166  0.24377
life_satFairly satisfied                               0.525  0.59945
life_satNot very satisfied                             2.017  0.04369
life_satNot at all satisfied                           0.023  0.98196
polintrMedium                                          0.751  0.45259
polintrLow                                             0.928  0.35366
polintrNot at all                                     -0.300  0.76443
left_right(5 - 6) Centre                               1.255  0.20939
left_right(7 -10) Right                                0.897  0.36960
social_alienation                                      2.570  0.01016
ethnic_minority1                                       1.974  0.04837
skincolor_minority1                                   -1.775  0.07587
religious_minority1                                   -1.794  0.07286
roma_minority1                                        -0.578  0.56295
sexual_minority1                                      -0.824  0.40992
disability_minority1                                   1.113  0.26588
suffered_discr1                                       -2.777  0.00549
gender_docsNo                                          5.769 7.96e-09
friends_transNo                                       -0.497  0.61895
friends_transRefusal (SPONTANEOUS)                     0.372  0.71004
n_friends_minorities                                   1.490  0.13622
n_actions_against_discri                              -2.320  0.02036
antilgbtq_rights                                       1.059  0.28975
minority_discri                                       -1.286  0.19851
country_nameBelgium                                   -2.482  0.01308
country_nameBulgaria                                   3.633  0.00028
country_nameCroatia                                   -0.020  0.98383
country_nameCyprus                                     1.376  0.16896
country_nameCzechia                                    0.193  0.84665
country_nameDenmark                                    0.059  0.95276
country_nameEstonia                                    1.493  0.13539
country_nameFinland                                    1.544  0.12257
country_nameFrance                                     0.619  0.53600
country_nameGermany                                    1.823  0.06831
country_nameGreece                                     0.384  0.70064
country_nameHungary                                   -0.591  0.55444
country_nameIreland                                    0.123  0.90192
country_nameItaly                                      0.756  0.44936
country_nameLatvia                                     2.141  0.03225
country_nameLithuania                                  0.359  0.71984
country_nameLuxembourg                                -0.051  0.95898
country_nameMalta                                     -0.960  0.33681
country_nameNetherlands                               -0.886  0.37542
country_namePoland                                     1.536  0.12449
country_namePortugal                                  -0.868  0.38530
country_nameRomania                                   -0.059  0.95320
country_nameSlovakia                                   0.779  0.43579
country_nameSlovenia                                   0.447  0.65483
country_nameSpain                                     -0.995  0.31985
country_nameSweden                                     2.565  0.01032
country_nameUnited Kingdom                             1.656  0.09775
                                                        
(Intercept)                                          ***
age                                                  ** 
genderWoman                                          *  
years_edu                                               
communitySmall or middle sized town                     
communityLarge town                                     
marital_statusSingle living with partner (5-8 in d7)    
marital_statusSingle (9-10 in d7)                       
marital_statusDivorced or separated (11-12 in d7)    *  
marital_statusWidow (13-14 in d7)                    .  
occupationManagers (10 to 12 in d15a)                   
occupationOther white collars (13 or 14 in d15a)        
occupationManual workers (15 to 18 in d15a)             
occupationHouse persons (1 in d15a)                     
occupationUnemployed (3 in d15a)                        
occupationRetired (4 in d15a)                           
occupationStudents (2 in d15a)                          
social_classThe lower middle class of society           
social_classThe middle class of society                 
social_classThe upper middle class of society           
social_classThe higher class of society                 
religionOrthodox Christian                              
religionProtestant                                      
religionOther Christian                                 
religionOther                                        ** 
religionMuslim                                       *  
religionNon-believers                                   
nonEU_national1                                         
phone_accessLandline only                               
phone_accessLandline & mobile                           
phone_accessNo telephone                                
bill_issuesFrom time to time                            
bill_issuesAlmost never/never                        *  
internet_useTwo or three times a week                   
internet_useAbout once a week                        .  
internet_useTwo or three times a month                  
internet_useLess often                                  
internet_useNever/No access                          *  
internet_useNo Internet access at all                   
life_satFairly satisfied                                
life_satNot very satisfied                           *  
life_satNot at all satisfied                            
polintrMedium                                           
polintrLow                                              
polintrNot at all                                       
left_right(5 - 6) Centre                                
left_right(7 -10) Right                                 
social_alienation                                    *  
ethnic_minority1                                     *  
skincolor_minority1                                  .  
religious_minority1                                  .  
roma_minority1                                          
sexual_minority1                                        
disability_minority1                                    
suffered_discr1                                      ** 
gender_docsNo                                        ***
friends_transNo                                         
friends_transRefusal (SPONTANEOUS)                      
n_friends_minorities                                    
n_actions_against_discri                             *  
antilgbtq_rights                                        
minority_discri                                         
country_nameBelgium                                  *  
country_nameBulgaria                                 ***
country_nameCroatia                                     
country_nameCyprus                                      
country_nameCzechia                                     
country_nameDenmark                                     
country_nameEstonia                                     
country_nameFinland                                     
country_nameFrance                                      
country_nameGermany                                  .  
country_nameGreece                                      
country_nameHungary                                     
country_nameIreland                                     
country_nameItaly                                       
country_nameLatvia                                   *  
country_nameLithuania                                   
country_nameLuxembourg                                  
country_nameMalta                                       
country_nameNetherlands                                 
country_namePoland                                      
country_namePortugal                                    
country_nameRomania                                     
country_nameSlovakia                                    
country_nameSlovenia                                    
country_nameSpain                                       
country_nameSweden                                   *  
country_nameUnited Kingdom                           .  
---
Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1

(Dispersion parameter for binomial family taken to be 1)

    Null deviance: 6149.9  on 18337  degrees of freedom
Residual deviance: 5702.8  on 18249  degrees of freedom
  (9100 observations deleted due to missingness)
AIC: 5880.8

Number of Fisher Scoring iterations: 7
broom::tidy(na_model)
# A tibble: 89 × 5
   term                          estimate std.error statistic  p.value
   <chr>                            <dbl>     <dbl>     <dbl>    <dbl>
 1 (Intercept)                   -5.10      0.505     -10.1   6.62e-24
 2 age                            0.0122    0.00422     2.89  3.88e- 3
 3 genderWoman                    0.165     0.0825      2.00  4.57e- 2
 4 years_edu                     -0.00591   0.00716    -0.826 4.09e- 1
 5 communitySmall or middle siz…  0.0601    0.0953      0.631 5.28e- 1
 6 communityLarge town           -0.0837    0.107      -0.783 4.33e- 1
 7 marital_statusSingle living … -0.229     0.153      -1.50  1.35e- 1
 8 marital_statusSingle (9-10 i… -0.152     0.149      -1.02  3.07e- 1
 9 marital_statusDivorced or se…  0.290     0.129       2.24  2.48e- 2
10 marital_statusWidow (13-14 i…  0.217     0.126       1.72  8.48e- 2
# ℹ 79 more rows
exp(coefficients(na_model))
                                         (Intercept) 
                                         0.006118521 
                                                 age 
                                         1.012252085 
                                         genderWoman 
                                         1.179144394 
                                           years_edu 
                                         0.994105573 
                 communitySmall or middle sized town 
                                         1.061910918 
                                 communityLarge town 
                                         0.919702513 
marital_statusSingle living with partner (5-8 in d7) 
                                         0.795281376 
                   marital_statusSingle (9-10 in d7) 
                                         0.859077470 
   marital_statusDivorced or separated (11-12 in d7) 
                                         1.336008000 
                   marital_statusWidow (13-14 in d7) 
                                         1.242109894 
               occupationManagers (10 to 12 in d15a) 
                                         1.077311509 
    occupationOther white collars (13 or 14 in d15a) 
                                         0.997840105 
         occupationManual workers (15 to 18 in d15a) 
                                         0.915892418 
                 occupationHouse persons (1 in d15a) 
                                         0.783111899 
                    occupationUnemployed (3 in d15a) 
                                         1.033494121 
                       occupationRetired (4 in d15a) 
                                         0.858326624 
                      occupationStudents (2 in d15a) 
                                         0.596316021 
       social_classThe lower middle class of society 
                                         0.826076903 
             social_classThe middle class of society 
                                         0.902562665 
       social_classThe upper middle class of society 
                                         0.952304428 
             social_classThe higher class of society 
                                         1.028443714 
                          religionOrthodox Christian 
                                         0.761516508 
                                  religionProtestant 
                                         1.174812676 
                             religionOther Christian 
                                         0.876232166 
                                       religionOther 
                                         0.453321737 
                                      religionMuslim 
                                         1.997077577 
                               religionNon-believers 
                                         0.979303553 
                                     nonEU_national1 
                                         0.690148654 
                           phone_accessLandline only 
                                         0.895177305 
                       phone_accessLandline & mobile 
                                         1.040514134 
                            phone_accessNo telephone 
                                         0.606132435 
                        bill_issuesFrom time to time 
                                         1.261863952 
                       bill_issuesAlmost never/never 
                                         1.580036385 
               internet_useTwo or three times a week 
                                         1.202538557 
                       internet_useAbout once a week 
                                         1.548620752 
              internet_useTwo or three times a month 
                                         0.205822438 
                              internet_useLess often 
                                         1.082401205 
                         internet_useNever/No access 
                                         1.337550906 
               internet_useNo Internet access at all 
                                         1.366822298 
                            life_satFairly satisfied 
                                         1.054685123 
                          life_satNot very satisfied 
                                         1.338345661 
                        life_satNot at all satisfied 
                                         1.005618084 
                                       polintrMedium 
                                         1.084013516 
                                          polintrLow 
                                         1.134678895 
                                   polintrNot at all 
                                         0.955679809 
                            left_right(5 - 6) Centre 
                                         1.130183275 
                             left_right(7 -10) Right 
                                         1.099231740 
                                   social_alienation 
                                         1.132173128 
                                    ethnic_minority1 
                                         1.585950517 
                                 skincolor_minority1 
                                         0.395659376 
                                 religious_minority1 
                                         0.616543469 
                                      roma_minority1 
                                         0.791340592 
                                    sexual_minority1 
                                         0.650987925 
                                disability_minority1 
                                         1.321797816 
                                     suffered_discr1 
                                         0.683231382 
                                       gender_docsNo 
                                         1.709613372 
                                     friends_transNo 
                                         0.927536237 
                  friends_transRefusal (SPONTANEOUS) 
                                         1.159127418 
                                n_friends_minorities 
                                         1.037755175 
                            n_actions_against_discri 
                                         0.860352034 
                                    antilgbtq_rights 
                                         1.057477224 
                                     minority_discri 
                                         0.971433339 
                                 country_nameBelgium 
                                         0.347421173 
                                country_nameBulgaria 
                                         3.519418325 
                                 country_nameCroatia 
                                         0.993092912 
                                  country_nameCyprus 
                                         1.856208043 
                                 country_nameCzechia 
                                         1.065640125 
                                 country_nameDenmark 
                                         1.020965585 
                                 country_nameEstonia 
                                         1.645499121 
                                 country_nameFinland 
                                         1.659691425 
                                  country_nameFrance 
                                         1.233003664 
                                 country_nameGermany 
                                         1.735979599 
                                  country_nameGreece 
                                         1.168625297 
                                 country_nameHungary 
                                         0.818975930 
                                 country_nameIreland 
                                         1.043881063 
                                   country_nameItaly 
                                         1.295477566 
                                  country_nameLatvia 
                                         1.987397162 
                               country_nameLithuania 
                                         1.125375345 
                              country_nameLuxembourg 
                                         0.977153472 
                                   country_nameMalta 
                                         0.538315374 
                             country_nameNetherlands 
                                         0.721830044 
                                  country_namePoland 
                                         1.651040115 
                                country_namePortugal 
                                         0.712123337 
                                 country_nameRomania 
                                         0.976758747 
                                country_nameSlovakia 
                                         1.283136036 
                                country_nameSlovenia 
                                         1.163574636 
                                   country_nameSpain 
                                         0.677063226 
                                  country_nameSweden 
                                         2.274838960 
                          country_nameUnited Kingdom 
                                         1.724509350 

Approach to test relationship to DK with splitting and undersampling:

# create new dataset with just vars we want, including age^2
dk_target2 <- dk_target |> 
  select(target_NA, age, antilgbtq_rights, internet_use, social_class, country_name) |> 
  mutate(age_sq = age*age, .after = age)

# to deal with some class imbalance, undersample from the majority group (NA = 0)
set.seed(123)
# Generate an index
index <- createDataPartition(dk_target2$target_NA, p = 0.7, list = FALSE, times = 1)

# Subset the dataframe
train <- dk_target2[index, ]
test <- dk_target2[-index, ]
# check splits 
prop.table(table(train$target_NA))

        0         1 
0.8787421 0.1212579 
prop.table(table(test$target_NA))

        0         1 
0.8844612 0.1155388 

Now undersample the majority

set.seed(123)
under <- ovun.sample(target_NA~., 
                     data=train, 
                     method = "under", 
                     N = 4000)$data 
    # limit the sample to 4000 obs as we have ~2300 for target minority class. 

table(under$target_NA)

   0    1 
2112 1888 
#run the rf model 
rfunder <- randomForest(target_NA~., data=under)
rfunder

Call:
 randomForest(formula = target_NA ~ ., data = under) 
               Type of random forest: regression
                     Number of trees: 500
No. of variables tried at each split: 2

          Mean of squared residuals: 0.2389922
                    % Var explained: 4.1

We see that only around 5% of the variance is explained.

Testing the NA values against paradata

Here we extend the model to see if paradata is related to changed non-response.

para <- paradata |> 
  bind_cols(trans_docs = data$trans_docs,
            age = data$age,
            gender = data$gender,
            country = data$country) |> 
  mutate(target_NA = ifelse(is.na(trans_docs), 1, 0)) |> 
  select(-serialid, -trans_docs)

summary(para$target_NA)
   Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
 0.0000  0.0000  0.0000  0.1195  0.0000  1.0000 
str(para)
tibble [27,438 × 9] (S3: tbl_df/tbl/data.frame)
 $ p2       : Factor w/ 6 levels "Before 8 h","8 - 12 h",..: 4 4 3 4 2 4 5 2 4 4 ...
  ..- attr(*, "label")= chr "TIME OF INTERVIEW"
 $ p3       : Factor w/ 246 levels "2 minutes","3",..: 44 39 37 30 30 25 26 33 39 39 ...
  ..- attr(*, "label")= chr "DURATION OF INTERVIEW"
 $ p3r      : Factor w/ 7 levels "Up to 14 minutes",..: 4 3 3 3 3 2 2 3 3 3 ...
  ..- attr(*, "label")= chr "DURATION OF INTERVIEW (RECODED)"
 $ p4       : Factor w/ 5 levels "Two (interviewer and respondent)",..: 1 1 1 1 1 1 1 1 1 1 ...
  ..- attr(*, "label")= chr "N OF PERSONS PRESENT DURING INTERVIEW"
 $ p5       : Factor w/ 5 levels "Excellent","Fair",..: 1 1 1 1 1 1 1 1 1 1 ...
  ..- attr(*, "label")= chr "RESPONDENT COOPERATION"
 $ age      : num [1:27438] 51 62 38 29 63 41 48 88 44 45 ...
 $ gender   : Factor w/ 2 levels "Man","Woman": 1 2 2 1 2 2 1 1 2 2 ...
 $ country  : chr [1:27438] "BE" "BE" "BE" "BE" ...
 $ target_NA: num [1:27438] 0 0 0 0 0 0 0 0 0 0 ...

First, again test correlation. We use Cramers V since we only have factors:

target_var <- "target_NA"
para_vars <- names(para)[names(para) != target_var]

cramers_v_results <- list()

for (variable in para_vars) {
    contingency_table <- table(para[[target_var]], 
                               para[[variable]])
    contingency_table_no_dk <- contingency_table[, colnames(contingency_table) != "DK"]
    cramers_v <- CramerV(contingency_table_no_dk) 
    # include this for no DK as it is all zero which creates errors
    cramers_v_results[[variable]] <- cramers_v
}


# Create a Tibble for Results
tibble(variable = names(cramers_v_results),
       cramers_v = unlist(cramers_v_results)) |> 
  arrange(desc(cramers_v))
# A tibble: 8 × 2
  variable cramers_v
  <chr>        <dbl>
1 country     0.168 
2 age         0.123 
3 p5          0.106 
4 p3          0.0916
5 gender      0.0292
6 p4          0.0165
7 p2          0.0116
8 p3r         0.0113

Again, we see low correlation with the paradata and cramers V.

Second, we run another logistic model with just Paradata included.

na_para_model <- glm(target_NA ~ p2 + p3r + p4 + p5 + age + I(age*age) + gender + factor(country), 
                     data = para, 
                     family=binomial(link = "logit"))

broom::tidy(na_para_model) |> 
  filter(p.value<0.05) |> 
  mutate(oddsratio = exp(estimate)) |> 
  select(term, oddsratio, p.value)
# A tibble: 25 × 3
   term              oddsratio  p.value
   <chr>                 <dbl>    <dbl>
 1 (Intercept)          0.0439 4.65e-12
 2 p4Four               0.694  4.20e- 2
 3 p5Fair               1.42   2.05e-15
 4 p5Average            1.74   8.91e-18
 5 p5Bad                3.49   2.14e-22
 6 age                  0.983  2.85e- 3
 7 I(age * age)         1.00   3.43e- 9
 8 genderWoman          1.14   1.07e- 3
 9 factor(country)BE    0.179  6.77e- 9
10 factor(country)BG    5.30   2.16e-31
# ℹ 15 more rows

We see that when controlling for age, gender and country, the survey cooperation variable is significant.

When compared to those with an excellent cooperation rating, people were more likely to respond. This increases with lacking cooperation. If cooperation was fair, there was around 40% more chance of NA, if cooperation was average, around 75% higher chance of NA. If cooperation was bad, there was about 350% higher chance of a NA response to our target variable.

Overall, the correlations with our target variables are low which means we don’t have a major concern. Some are interesting e.g. interview cooperation. The worse the cooperation, the more likely to not respond to the question. This could be underreporting No votes, because as we saw in the descriptive analysis, the worse the cooperation, the higher the No vote for supporting trans_docs. There could also be some reverse causality, as not responding leads to a worse cooperation score. But the odds ratios here are very high.

Imputing missing data

As we have different types of variables we decide to go with the default methods. Selecting the best method for each type of variable would be too computationally intensive

# Excluding target variable and other useless variables
imputation_data <- data |> 
  select(-c(serialid, country, trans_docs))

# Running it with the default methods
imputed_data <- mice(imputation_data, m = 1, seed=1234)

 iter imp variable
  1   1  years_edu  community  marital_status  social_class  religion  bill_issues  life_sat  left_right  social_alienation  gender_docs  friends_trans  antilgbtq_rights  minority_discri
  2   1  years_edu  community  marital_status  social_class  religion  bill_issues  life_sat  left_right  social_alienation  gender_docs  friends_trans  antilgbtq_rights  minority_discri
  3   1  years_edu  community  marital_status  social_class  religion  bill_issues  life_sat  left_right  social_alienation  gender_docs  friends_trans  antilgbtq_rights  minority_discri
  4   1  years_edu  community  marital_status  social_class  religion  bill_issues  life_sat  left_right  social_alienation  gender_docs  friends_trans  antilgbtq_rights  minority_discri
  5   1  years_edu  community  marital_status  social_class  religion  bill_issues  life_sat  left_right  social_alienation  gender_docs  friends_trans  antilgbtq_rights  minority_discri
# By default: numerical variables -> pmm, binary factors -> logreg, > 2 levels factors -> polyreg
imputed_data$method
                     age                   gender 
                      ""                       "" 
               years_edu                community 
                   "pmm"                "polyreg" 
          marital_status               occupation 
               "polyreg"                       "" 
            social_class                 religion 
               "polyreg"                "polyreg" 
          nonEU_national             phone_access 
                      ""                       "" 
             bill_issues             internet_use 
               "polyreg"                       "" 
                life_sat                  polintr 
               "polyreg"                       "" 
              left_right        social_alienation 
               "polyreg"                    "pmm" 
         ethnic_minority       skincolor_minority 
                      ""                       "" 
      religious_minority            roma_minority 
                      ""                       "" 
         sexual_minority      disability_minority 
                      ""                       "" 
          suffered_discr              gender_docs 
                      ""                 "logreg" 
           friends_trans     n_friends_minorities 
               "polyreg"                       "" 
n_actions_against_discri         antilgbtq_rights 
                      ""                    "pmm" 
         minority_discri 
                   "pmm" 
final_data <- complete(imputed_data)

colSums(is.na(imputation_data))
                     age                   gender 
                       0                        0 
               years_edu                community 
                     387                       14 
          marital_status               occupation 
                     175                        0 
            social_class                 religion 
                    1021                      483 
          nonEU_national             phone_access 
                       0                        0 
             bill_issues             internet_use 
                     379                        0 
                life_sat                  polintr 
                     102                        0 
              left_right        social_alienation 
                    4689                     1000 
         ethnic_minority       skincolor_minority 
                       0                        0 
      religious_minority            roma_minority 
                       0                        0 
         sexual_minority      disability_minority 
                       0                        0 
          suffered_discr              gender_docs 
                       0                     3187 
           friends_trans     n_friends_minorities 
                     968                        0 
n_actions_against_discri         antilgbtq_rights 
                       0                      791 
         minority_discri 
                     355 
colSums(is.na(final_data))
                     age                   gender 
                       0                        0 
               years_edu                community 
                       0                        0 
          marital_status               occupation 
                       0                        0 
            social_class                 religion 
                       0                        0 
          nonEU_national             phone_access 
                       0                        0 
             bill_issues             internet_use 
                       0                        0 
                life_sat                  polintr 
                       0                        0 
              left_right        social_alienation 
                       0                        0 
         ethnic_minority       skincolor_minority 
                       0                        0 
      religious_minority            roma_minority 
                       0                        0 
         sexual_minority      disability_minority 
                       0                        0 
          suffered_discr              gender_docs 
                       0                        0 
           friends_trans     n_friends_minorities 
                       0                        0 
n_actions_against_discri         antilgbtq_rights 
                       0                        0 
         minority_discri 
                       0 
final_data <- final_data |> 
  cbind(data$trans_docs) |> 
  cbind(data$country) |>
  rename("trans_docs" = "data$trans_docs",
         "country" = "data$country") |> 
  relocate(country, .before = everything())

We know that it would be better to impute multiple datasets and then pool the results of different regressions on those different datasets together, but running more than one multilevel regression would be too computationally intensive and so we are not able to do this.

Joining together all our data

country_level_data stores all our data defined at the country level.

final_data stores all our data (after imputation) for individual level variables.

complete_df <- final_data |> 
  left_join(country_level_data, 
            by = join_by(country == iso2c)) |> 
  select(-c(country.y, iso3c))

Explanatory model

To be finished…

  1. Run logistic with all variables and extract only the significant variables

  2. Confirm this is similar to the results we obtain using stepwise regression/lasso regularization

  3. Based on 1 & 2 decide which individual level variables to include in the mixed model

  4. Build the mixed model (look at the mixed model section for further details on how this needs to be built)

Simple logistic regression

I am using only individual level data for now. This is a simple model to see at the global level i.e. no country level control, which variables are significant. The numeric data has also been scaled.

datalr <- final_data |> 
  # Dropping NAs (there should be NAs only in our target variable)
  drop_na() |> 
  # Selecting only predictor variables
  select(-"country") |> 
  # Scale variables 
  mutate(across(where(is.numeric), scale)) |> 
  # Transforming target to binary numeric Yes=1, No=0
  mutate(trans_docs = as.numeric(trans_docs == "Yes"))
  
# now run the full model
simple_logistic <- glm(trans_docs ~ ., data = datalr, family = binomial(link = "logit"))

# Save the summary
logistic_summary <- summary(simple_logistic)

# create a tibble to more easily search through significant variables
logistic_results <- tibble(
  broom::tidy(simple_logistic) |>
    filter(p.value<0.05) |>
    mutate(oddsratio = exp(estimate)) |>
    select(term, estimate, oddsratio, p.value) |> 
    arrange(oddsratio))
logistic_results
# A tibble: 26 × 4
   term                                  estimate oddsratio   p.value
   <chr>                                    <dbl>     <dbl>     <dbl>
 1 gender_docsNo                           -2.66     0.0697 0        
 2 friends_transRefusal (SPONTANEOUS)      -0.798    0.450  2.05e-  5
 3 antilgbtq_rights                        -0.699    0.497  1.16e-194
 4 roma_minority1                          -0.568    0.567  1.43e-  4
 5 internet_useTwo or three times a week   -0.418    0.658  4.29e-  8
 6 life_satNot at all satisfied            -0.395    0.673  3.56e-  4
 7 internet_useNever/No access             -0.348    0.706  1.92e-  7
 8 bill_issuesFrom time to time            -0.335    0.716  8.36e-  6
 9 internet_useAbout once a week           -0.332    0.718  2.13e-  2
10 occupationRetired (4 in d15a)           -0.321    0.725  1.24e-  4
# ℹ 16 more rows
Interpeting results

To interpret the coefficients as odds ratios, anything above 1 indicates they are more likely to support the changes to civil documents for trans people.

The logistic regression shows that 26 statistically significant terms. This includes factors variables with multiple terms. Of our 29 scaled variables, the significant variables (at the 5% level) are:

More likely to OPPPOSE the right to change civil documents for trans people, include:
- men (compared to wom) - younger people - people who oppose legal rights to add a third-gender in official docs (compared to those who do) - people who refused to answer whether they have trans friends (compared to those who do) - people who are more financially sound (have fewer bill issues) - people not satisfied with their life (compared to those who are ‘very satisfied’) - people who identified as roma or an ethnic minority - people who are more discriminatory against minorities

More likely to SUPPORT the the right - older people - women - people who were self-employed (compared to all other occupation types incl students) - unmarried (single) people - non-believers (religious) - people with a landline and mobile - people who use the internet everyday/almost everyday (compared to all other internet use categories) - people who reported being more left wing (compared to right wing) - people who had friends in minority groups.


NUMERIC VARIABLES

Without scaling, we interpret logistic regression output as:

coef(simple_logistic): these coefficients represent the change in the log-odds for a one-unit increase in the corresponding independent variable

exp(coef(simple_logistic)): the exponential of the slope coefficient (exp(B)) tells us the change of the odds if the independent variable increases by one unit

If the data is scaled:

A coefficient B (from a logistic regression) now reflects the change in the log-odds for a one standard deviation increase in the predictor variable, rather than a one-unit increase in the original scale.

The odds ratio (exp(B)) now tells you how the odds change with a one standard deviation increase in the predictor variable, rather than a one-unit increase.

Here we compare the pre and post transformation of coefficients for interpretation:

# all the coefficients
head(coef(simple_logistic))
                        (Intercept) 
                         2.69303178 
                                age 
                         0.20879798 
                        genderWoman 
                         0.26342657 
                          years_edu 
                        -0.01215087 
communitySmall or middle sized town 
                         0.01810837 
                communityLarge town 
                        -0.04039684 
# for their interpretation
head(exp(coef(simple_logistic)))
                        (Intercept) 
                         14.7764069 
                                age 
                          1.2321960 
                        genderWoman 
                          1.3013817 
                          years_edu 
                          0.9879227 
communitySmall or middle sized town 
                          1.0182733 
                communityLarge town 
                          0.9604082 

FACTOR VARIABLES

Factor variables when exponentialised give the likelihood to respond no/yes relative to the base group in the factor variable. We use the function factors to view the levels and identify the base group.

To assist with interpretation of factor outputs:

Here is a function to identify all the base levels in each factor group. Useful to refer to during analysis of different logistic models.

extract_base_groups <- function(df) {

  # extract factor vars only and list to print values
  factor_vars <- names(final_data)[sapply(final_data, is.factor)]
  base_groups <- list()
  
  # loop through values to check all levels
  for (var in factor_vars) {
    if (length(levels(df[[var]])) > 0) { # Check step - should be TRUE for all selected. 
      contrast_matrix <- contrasts(df[[var]])
      if (is.null(contrast_matrix)) {
        base_groups[[var]] <- levels(df[[var]])[1] # check only - shouldn't ever run
      } else {
        base_group_level <- levels(df[[var]])[rowSums(abs(contrast_matrix)) == 0] # base group is the one with all zeroes, so we extract that
        base_groups[[var]] <- base_group_level
      }
    } else {
      base_groups[[var]] <- NA # Indicate non-factor or factor with no levels.
    }
  }
  return(base_groups)
}

# run function with 'final data' and print a tidy output
factor_bases <- extract_base_groups(final_data)

factor_bases <- as_tibble(factor_bases) |> 
  pivot_longer(cols = everything(), 
               names_to = "vars",
               values_to = "base_group")

factor_bases
# A tibble: 23 × 2
   vars           base_group                    
   <chr>          <chr>                         
 1 gender         Man                           
 2 community      Rural area or village         
 3 marital_status (Re-)Married (1-4 in d7)      
 4 occupation     Self-employed (5 to 9 in d15a)
 5 social_class   The working class of society  
 6 religion       Catholic                      
 7 nonEU_national 0                             
 8 phone_access   Mobile only                   
 9 bill_issues    Most of the time              
10 internet_use   Everyday/Almost everyday      
# ℹ 13 more rows
Model performance - Simple logistic

Here, we test the models ability to classify people as supporting or not supporting the rights.

# AIC of model
simple_logistic$aic
[1] 19544.18
#predicted probabilities of being a 1 (i.e. a refusal of possibility of trans doc)
predicted_probs <- simple_logistic$fitted.values
# same by running
# predicted_probs <- predict(simple_logistic, type = "response")
head(predicted_probs)
        1         2         3         4         5         6 
0.3463520 0.4321645 0.5170989 0.5799662 0.9141149 0.5131253 
# Turning them to classes using custom threshold
predicted_classes <- ifelse(predicted_probs > 0.5, 1, 0)
head(predicted_classes)
1 2 3 4 5 6 
0 0 1 1 1 1 

Get the confusion matrix:

confusionMatrix(as.factor(datalr$trans_docs), as.factor(predicted_classes))
Confusion Matrix and Statistics

          Reference
Prediction     0     1
         0  7608  2087
         1  2246 12217
                                          
               Accuracy : 0.8206          
                 95% CI : (0.8157, 0.8255)
    No Information Rate : 0.5921          
    P-Value [Acc > NIR] : < 2e-16         
                                          
                  Kappa : 0.6277          
                                          
 Mcnemar's Test P-Value : 0.01638         
                                          
            Sensitivity : 0.7721          
            Specificity : 0.8541          
         Pos Pred Value : 0.7847          
         Neg Pred Value : 0.8447          
             Prevalence : 0.4079          
         Detection Rate : 0.3149          
   Detection Prevalence : 0.4013          
      Balanced Accuracy : 0.8131          
                                          
       'Positive' Class : 0               
                                          

The simple model predicted people’s response with 82% accuracy. That is quite decent for a basic first model. This shows the response is quite explainable with the data we have. The model is slightly better at predicting those who do not support than those who do. Seen by higher specificity than sensitivity (85% vs 77%). But they are both comparable which is good and confirms we don’t have great class imbalance.

roc_obj <- roc(datalr$trans_docs, predicted_probs)

# Terrible graphs, do we have better ones? Not sure. I think the first is good enough. 
pROC::ggroc(roc_obj)
plot(roc_obj)
coords(roc_obj, "best")
  threshold specificity sensitivity
1 0.5937607    0.843115   0.7938187
auc(datalr$trans_docs, predicted_probs)
Area under the curve: 0.8937

Stepwise regression

Chooses the best simple logistic model based on the lowest AIC achievable

set.seed(123)
stepAIC <- step(simple_logistic, direction = "both", trace=0)
stepAIC

Call:  glm(formula = trans_docs ~ age + gender + marital_status + occupation + 
    religion + phone_access + bill_issues + internet_use + life_sat + 
    left_right + ethnic_minority + roma_minority + suffered_discr + 
    gender_docs + friends_trans + n_friends_minorities + n_actions_against_discri + 
    antilgbtq_rights + minority_discri, family = binomial(link = "logit"), 
    data = datalr)

Coefficients:
                                         (Intercept)  
                                             2.62467  
                                                 age  
                                             0.20698  
                                         genderWoman  
                                             0.26440  
marital_statusSingle living with partner (5-8 in d7)  
                                             0.04042  
                   marital_statusSingle (9-10 in d7)  
                                             0.13987  
   marital_statusDivorced or separated (11-12 in d7)  
                                             0.10517  
                   marital_statusWidow (13-14 in d7)  
                                            -0.10979  
               occupationManagers (10 to 12 in d15a)  
                                             0.01744  
    occupationOther white collars (13 or 14 in d15a)  
                                            -0.25937  
         occupationManual workers (15 to 18 in d15a)  
                                            -0.14375  
                 occupationHouse persons (1 in d15a)  
                                             0.05889  
                    occupationUnemployed (3 in d15a)  
                                            -0.12589  
                       occupationRetired (4 in d15a)  
                                            -0.30665  
                      occupationStudents (2 in d15a)  
                                            -0.29364  
                          religionOrthodox Christian  
                                            -0.12432  
                                  religionProtestant  
                                             0.08546  
                             religionOther Christian  
                                            -0.13836  
                                       religionOther  
                                             0.06244  
                                      religionMuslim  
                                            -0.24374  
                               religionNon-believers  
                                             0.13104  
                           phone_accessLandline only  
                                            -0.09735  
                       phone_accessLandline & mobile  
                                             0.27311  
                            phone_accessNo telephone  
                                            -0.19336  
                        bill_issuesFrom time to time  
                                            -0.34079  
                       bill_issuesAlmost never/never  
                                            -0.22203  
               internet_useTwo or three times a week  
                                            -0.41597  
                       internet_useAbout once a week  
                                            -0.31328  
              internet_useTwo or three times a month  
                                            -0.09201  
                              internet_useLess often  
                                             0.02229  
                         internet_useNever/No access  
                                            -0.33028  
               internet_useNo Internet access at all  
                                            -0.02332  
                            life_satFairly satisfied  
                                             0.05142  
                          life_satNot very satisfied  
                                            -0.14512  
                        life_satNot at all satisfied  
                                            -0.38741  
                            left_right(5 - 6) Centre  
                                             0.05631  
                             left_right(7 -10) Right  
                                            -0.17298  
                                    ethnic_minority1  
                                            -0.26298  
                                      roma_minority1  
                                            -0.58673  
                                     suffered_discr1  
                                            -0.22381  
                                       gender_docsNo  
                                            -2.65983  
                                     friends_transNo  
                                            -0.13252  
                  friends_transRefusal (SPONTANEOUS)  
                                            -0.79810  
                                n_friends_minorities  
                                             0.15912  
                            n_actions_against_discri  
                                             0.03980  
                                    antilgbtq_rights  
                                            -0.69753  
                                     minority_discri  
                                            -0.23593  

Degrees of Freedom: 24157 Total (i.e. Null);  24112 Residual
Null Deviance:      32540 
Residual Deviance: 19430    AIC: 19530

The stepwise regression has 19 of the 29 variables included in it’s best model. It is quite consistent with what our significant variables were above, so we will not provide further commentary. Compared to the full model, this reduced model does not provide a statistically significant improvement in fit. But it does give us a more simple model and shows us what individual level variable may be most important overall.

anova(simple_logistic, stepAIC)
Analysis of Deviance Table

Model 1: trans_docs ~ age + gender + years_edu + community + marital_status + 
    occupation + social_class + religion + nonEU_national + phone_access + 
    bill_issues + internet_use + life_sat + polintr + left_right + 
    social_alienation + ethnic_minority + skincolor_minority + 
    religious_minority + roma_minority + sexual_minority + disability_minority + 
    suffered_discr + gender_docs + friends_trans + n_friends_minorities + 
    n_actions_against_discri + antilgbtq_rights + minority_discri
Model 2: trans_docs ~ age + gender + marital_status + occupation + religion + 
    phone_access + bill_issues + internet_use + life_sat + left_right + 
    ethnic_minority + roma_minority + suffered_discr + gender_docs + 
    friends_trans + n_friends_minorities + n_actions_against_discri + 
    antilgbtq_rights + minority_discri
  Resid. Df Resid. Dev  Df Deviance Pr(>Chi)
1     24096      19420                      
2     24112      19434 -16  -14.121   0.5897

DIEGO: ask for an explanation of this

Lasso regularization

We still have too many variables for a mixed model. So here we will use Lasso to keep only our most important variables for the mixed models.

Without this step, the glmer stage is too computationally expensive.

lasso_data <- final_data |> 
  # Doing same preprocessing as done for simple logistic
  drop_na() |> 
  select(-"country") |> 
  mutate(across(where(is.numeric), scale)) |> 
  mutate(trans_docs = as.numeric(trans_docs == "Yes")) 

# Dummifying all levels to see whether some levels are particularly important
lasso_data <- lasso_data %>% 
  dummy_cols(select_columns = names(.)[sapply(., is.factor)],
             remove_selected_columns = TRUE,
             remove_first_dummy = TRUE)
  

# Convert data into a matrix for glmnet
x_lasso <- lasso_data |> select(-trans_docs) |> as.matrix() 
y_lasso <- lasso_data |> select(trans_docs) |> as.matrix()

set.seed(123)

# Define lamdas
lambda_seq <- 10^seq(-2, -5, length.out = 100)

# Fit the Lasso model (alpha = 1 for Lasso regularization)
lasso_model <- cv.glmnet(x_lasso, y_lasso, family = "binomial", alpha = 1, lambda = lambda_seq)

lasso_model$lambda.1se # The largest lambda within one standard error of lambda.min. This results in a simpler model with fewer selected features.
[1] 0.007564633
lasso_model$lambda.min
[1] 0.0006579332
# Get all the coefficients
coefficients <- coef(lasso_model, s = "lambda.1se")
# Filter for the non-zero ones
non_zero_features <- rownames(coefficients)[which(coefficients != 0)]
non_zero_features
 [1] "(Intercept)"                           
 [2] "age"                                   
 [3] "n_friends_minorities"                  
 [4] "antilgbtq_rights"                      
 [5] "minority_discri"                       
 [6] "gender_Woman"                          
 [7] "occupation_Managers (10 to 12 in d15a)"
 [8] "religion_Orthodox Christian"           
 [9] "phone_access_Landline & mobile"        
[10] "bill_issues_From time to time"         
[11] "internet_use_Two or three times a week"
[12] "internet_use_Never/No access"          
[13] "life_sat_Not very satisfied"           
[14] "life_sat_Not at all satisfied"         
[15] "left_right_(7 -10) Right"              
[16] "ethnic_minority_1"                     
[17] "roma_minority_1"                       
[18] "suffered_discr_1"                      
[19] "gender_docs_No"                        
[20] "friends_trans_Refusal (SPONTANEOUS)"   

Lasso includes variables similar to what was suggested by our initial logistic regression and the subsequent stepwise.

In particular we can see again that:

  1. age is relevant

  2. gender is relevant

  3. It matters whether you have friends that belong to minorites (n_friends_minorities)

Also `ant

Final variable selection

From these hints above and general intuition, we will select the following variables as our individual level fixed effects in the mixed level model:

And these are our pre-defined fixed

Mixed model

Random Intercept Model:

Allows the baseline level (intercept) to vary across groups. Assumes the relationship between predictors and outcome (slope) is the same for all groups

In R syntax: y ~ x + (1|group)

Example: Different schools might have different average test scores (random intercepts), but the effect of study hours on test scores is the same across all schools


Random Slope Model:

Allows the effect of a predictor (slope) to vary across groups. Can be used with or without random intercepts.

In R syntax: y ~ x + (0+x|group) for random slope only, or y ~ x + (1+x|group) for both random intercept and slope

Example: The effect of study hours on test scores might be stronger in some schools than others (random slopes)

Random intercept models account for different baselines between groups, while random slope models account for different relationships between predictors and outcomes across groups. When both random intercepts and slopes are included, you’re allowing both the baseline and the effect of predictors to vary by group.


Interactions between group-level (higher-level) variables and individual-level (lower-level) variables in mixed models are called cross-level interactions.

Cross-level interactions are particularly useful in multilevel research because they help you understand how the relationship between an individual-level predictor and the outcome varies as a function of a group-level characteristic.

For example, in educational research: 1) Individual level: student characteristics (study time, prior knowledge). 2) Group level: school or classroom characteristics (class size, teaching method). 3) Cross-level interaction: Does the effect of study time on performance depend on class size?

Running the glmer models

To model, we will follow: Approach to multilevel model building based on Hox (2010)

1/ Null Model (Random Intercept only) 2/ Add independent Level 1 variables 3/ Add independent Level 2 variables 4/ Add random slopes 5/ (Cross-level) interactions

Each step, check whether your model is significantly improved compared to the previous one.

We could run these different models and select the best one: null_glmer -> only country random effects for a baseline glmer_stepwise -> using the best stepwise model best model for individual fixed effects + adding country random effects glmer_lasso -> using the lasso model fixed individual level effects + country glmer_level2 -> using the best model from above and adding in all country level fixed effects too glmer_cross_level -> the model using integrated

# Switching to df containing both individual and country level
complete_df <- complete_df |> 
  drop_na() # should be zero as we cleaned before but just in case 

# Scaling the variables speeds up the running time. However we loose interpretation? maybe the best thing to do is to center them rather than scaling?
scaled_df <- complete_df |>
  mutate(across(where(is.numeric), scale))

# include glmer null model for comparison for improvements - only has random intercept
null_glmer_model <- glmer(trans_docs ~ (1|country),
                          data = scaled_df, 
                          family=binomial(link="logit"))


## running the level 1 glmer model (indiviudal fixed effects + country random effects)
    # variable selection from the stepwise model output
# this took 7.6 minutes to run WITH the scaled data, saved output locally
      # start <- Sys.time()
      # glmer_model_level1 <- glmer(
      #   # target
      #   trans_docs ~
      #     #individual data - significant from stepwise testing
      #     age + gender + marital_status + occupation + 
      #     religion + phone_access + bill_issues + internet_use + life_sat + 
      #     left_right + ethnic_minority + roma_minority + suffered_discr + 
      #     gender_docs + friends_trans + n_friends_minorities + n_actions_against_discri + 
      #     antilgbtq_rights + minority_discri + (1|country),
      #   data = scaled_df,
      #   family = binomial(link="logit")
      #     ) 
      # end <- Sys.time()
      # end-start

      # glmer_model_level1
      # output_glmer_1 <- broom.mixed::tidy(glmer_model_level1)

## running the level 2 glmer model (individual & country fixed effects + country random effects)

# took 10.8 minutes to run so commented out. Saved output locally 
      # start <- Sys.time()
      # glmer_model_level2 <- glmer(
      #   # target variable
      #   trans_docs ~
      #     #individual level fixed effects
      #     age + gender + marital_status + occupation +
      #     religion + phone_access + bill_issues + internet_use + life_sat +
      #     left_right + ethnic_minority + roma_minority + suffered_discr +
      #     gender_docs + friends_trans + n_friends_minorities + n_actions_against_discri +
      #     antilgbtq_rights + minority_discri + 
      #     #country level fixed effects
      #     gdp_pc_ppp + gender_inequality_index + lgbt_policy_index + democracy_index +
      #     # random effects of country
      #     (1|country),
      #   data = scaled_df,
      #   family = binomial(link="logit")
      #           )
      # end <- Sys.time()
      # end-start
      # output_glmer_2 <- broom.mixed::tidy(glmer_model_level2)


# glmer model with cross-level interactions
glmer_model <- glmer(trans_docs ~ gender:lgbt_policy_index + gender*gender_inequality_index + religion*gdp_pc_ppp + (1 | country), data=scaled_df, family=binomial(link="logit"))



## saving the level1 and level2 outputs to file for review of full model effects
    #write_csv2(output_glmer_1, "glmer_level1_model_output.csv")
    #write_csv2(output_glmer_2, "glmer_level2_model_output.csv") 
## writing output for AIC/BIC and saving too    
    # glmer_compare <- anova(null_glmer_model, glmer_model_level1, glmer_model_level2, glmer_model)
    # write_csv2(glmer_compare, "glmer_compare_basicmodels.csv") 


#variable1*variable2 includes both the two variables separetely and their interaction
#variable1:variable2 includes only the interaction
#+ (1|country) country is the grouping variable, means it includes different intercepts for each country

summary(glmer_model) # print in better tables as Marga likes
Generalized linear mixed model fit by maximum likelihood (Laplace
  Approximation) [glmerMod]
 Family: binomial  ( logit )
Formula: 
trans_docs ~ gender:lgbt_policy_index + gender * gender_inequality_index +  
    religion * gdp_pc_ppp + (1 | country)
   Data: scaled_df

     AIC      BIC   logLik deviance df.resid 
 27760.0  27921.9 -13860.0  27720.0    24138 

Scaled residuals: 
    Min      1Q  Median      3Q     Max 
-2.7416 -0.6925 -0.4228  0.8840  4.3145 

Random effects:
 Groups  Name        Variance Std.Dev.
 country (Intercept) 0.2811   0.5302  
Number of obs: 24158, groups:  country, 28

Fixed effects:
                                      Estimate Std. Error z value
(Intercept)                           -0.13251    0.10579  -1.253
genderWoman                           -0.45316    0.03005 -15.079
gender_inequality_index                0.24291    0.13625   1.783
religionOrthodox Christian             0.14645    0.08187   1.789
religionProtestant                    -0.13895    0.06647  -2.091
religionOther Christian                0.12570    0.07721   1.628
religionOther                         -0.21751    0.07081  -3.072
religionMuslim                         0.30067    0.12733   2.361
religionNon-believers                 -0.56486    0.04553 -12.407
gdp_pc_ppp                            -0.17017    0.10534  -1.615
genderMan:lgbt_policy_index           -0.43635    0.12779  -3.414
genderWoman:lgbt_policy_index         -0.56817    0.12769  -4.450
genderWoman:gender_inequality_index    0.03764    0.04140   0.909
religionOrthodox Christian:gdp_pc_ppp  0.16990    0.09189   1.849
religionProtestant:gdp_pc_ppp          0.15571    0.08005   1.945
religionOther Christian:gdp_pc_ppp     0.04970    0.08077   0.615
religionOther:gdp_pc_ppp               0.10347    0.06959   1.487
religionMuslim:gdp_pc_ppp              0.24140    0.12339   1.956
religionNon-believers:gdp_pc_ppp       0.01368    0.04644   0.294
                                      Pr(>|z|)    
(Intercept)                           0.210336    
genderWoman                            < 2e-16 ***
gender_inequality_index               0.074613 .  
religionOrthodox Christian            0.073659 .  
religionProtestant                    0.036564 *  
religionOther Christian               0.103541    
religionOther                         0.002129 ** 
religionMuslim                        0.018209 *  
religionNon-believers                  < 2e-16 ***
gdp_pc_ppp                            0.106205    
genderMan:lgbt_policy_index           0.000639 ***
genderWoman:lgbt_policy_index          8.6e-06 ***
genderWoman:gender_inequality_index   0.363264    
religionOrthodox Christian:gdp_pc_ppp 0.064484 .  
religionProtestant:gdp_pc_ppp         0.051760 .  
religionOther Christian:gdp_pc_ppp    0.538373    
religionOther:gdp_pc_ppp              0.137032    
religionMuslim:gdp_pc_ppp             0.050425 .  
religionNon-believers:gdp_pc_ppp      0.768383    
---
Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
# To calculate the intraclass coefficient (ICC) for the model, we use the ICC function from performance. 

# Calculate ICC for the null model, we get around 22% explained 
performance::icc(null_glmer_model)
# Intraclass Correlation Coefficient

    Adjusted ICC: 0.227
  Unadjusted ICC: 0.227
# When we run for the model with scaled data, we get 7% ICC 
performance::icc(glmer_model)
# Intraclass Correlation Coefficient

    Adjusted ICC: 0.079
  Unadjusted ICC: 0.064
# this gives us the following significant variables: age, gender, occupation, religion, phone_access, bill_issues, internet_use, left_right, ethnic_minority_ 

# we exclude these non significant variable: martial_status,  

The idea is to run interactions between individual level variables and country level variables choosing pair which make sense (ex. does the effect of being female on support for trans docs depend on the gender equality index? –> did this by doing gender*gender_inequality_index)

Let’s use our brain and common sense to choose the best combinations

Predictive model

Summarize individual data to a country level (ex. percentage of population living in rural areas by country, percentage of people from minority x by country)

Run random forest/gradient boosting/logistic regression with leave-one-out cross validation

Leave-One-Out Cross-Validation (LOOCV): LOOCV is a special case of k-fold cross-validation, where k = the number of observations (n).

That means: For each observation (1 out of 28), the model is trained on the remaining 27 rows and tested on the left-out row. This process repeats 28 times (once per row). The final performance metric (e.g., accuracy, RMSE) is the average of all 28 test results.

Aggregating individual data to country level

We should be building a dataframe with 28 rows (1 per country), but many variables (ex, percentage of christian people by country, percentage of very satisfied with lives people by country, percentage of people that belong to the roma minority etc.; our target variable would become % of people that support trans_docs by country)

In the next steps we will synthesize the information from the individual respondents into country-level variables.

Using means for numeric variables:

names(select(final_data, where(is.numeric))) # using final_data because it still has "country", which we dropped for complete_df
[1] "age"                      "years_edu"               
[3] "social_alienation"        "n_friends_minorities"    
[5] "n_actions_against_discri" "antilgbtq_rights"        
[7] "minority_discri"         
data_num <- final_data |> 
  group_by(country) |> 
  summarise(across(where(is.numeric), ~mean(.), .names = "mean_{.col}"))

As well as for dummies:

# searching for factor variables with two levels

dummy_names <- names(final_data)[sapply(final_data, is.factor) & sapply(final_data, function(x) length(levels(x)) == 2)]
dummy_names
 [1] "gender"              "nonEU_national"      "ethnic_minority"    
 [4] "skincolor_minority"  "religious_minority"  "roma_minority"      
 [7] "sexual_minority"     "disability_minority" "suffered_discr"     
[10] "gender_docs"         "trans_docs"         
dummy_levels <- lapply(final_data[dummy_names], levels)
dummy_levels
$gender
[1] "Man"   "Woman"

$nonEU_national
[1] "0" "1"

$ethnic_minority
[1] "0" "1"

$skincolor_minority
[1] "0" "1"

$religious_minority
[1] "0" "1"

$roma_minority
[1] "0" "1"

$sexual_minority
[1] "0" "1"

$disability_minority
[1] "0" "1"

$suffered_discr
[1] "0" "1"

$gender_docs
[1] "Yes" "No" 

$trans_docs
[1] "Yes" "No" 
colSums(is.na(final_data[dummy_names]))
             gender      nonEU_national     ethnic_minority 
                  0                   0                   0 
 skincolor_minority  religious_minority       roma_minority 
                  0                   0                   0 
    sexual_minority disability_minority      suffered_discr 
                  0                   0                   0 
        gender_docs          trans_docs 
                  0                3280 

After imputations only the target variable should have NAs. They have already been dropped before so no variable has NAs

data_dummy <- final_data %>%
  select(country, all_of(dummy_names)) %>%
  mutate(across(all_of(dummy_names),
                ~ case_when(
                  . %in% c("0", "1") ~ as.numeric(as.character(.)),  # convert "0"/"1" to 0/1
                  . %in% c("Yes", "No") ~ recode(., "Yes" = 1, "No" = 0),  # convert "Yes"/"No" to 1/0
                  . %in% c("Man", "Woman") ~ recode(., "Man" = 1, "Woman" = 0),  # convert "Man"/"Woman" to 1/0
                  TRUE ~ NA  # assign NA to other unexpected values
                ),
                .names = "{.col}_num"))

colSums(is.na(data_dummy)) # The warning is weird as there seem to be no NAs
                country                  gender 
                      0                       0 
         nonEU_national         ethnic_minority 
                      0                       0 
     skincolor_minority      religious_minority 
                      0                       0 
          roma_minority         sexual_minority 
                      0                       0 
    disability_minority          suffered_discr 
                      0                       0 
            gender_docs              trans_docs 
                      0                    3280 
             gender_num      nonEU_national_num 
                      0                       0 
    ethnic_minority_num  skincolor_minority_num 
                      0                       0 
 religious_minority_num       roma_minority_num 
                      0                       0 
    sexual_minority_num disability_minority_num 
                      0                       0 
     suffered_discr_num         gender_docs_num 
                      0                       0 
         trans_docs_num 
                   3280 

I converted factors with 2 levels to numerical 0-1 so we can compute their means.

Deleted the column calculating the % of NAs in trans_doc because although useful those NAs had already been dropped so it was returning all 0s

# country means
data_dummy <- data_dummy %>%
  group_by(country) %>%
  summarise(
    across(ends_with("_num"), ~ mean(.x, na.rm = TRUE)),
    .groups = "drop"
  )


# substitute the "_num" suffix with a "mean_" prefix so it has the same format as the variables in data_num
data_dummy <- data_dummy %>%
  rename_with(~ paste0("mean_", str_remove(., "_num$")), ends_with("_num"))

colSums(is.na(data_dummy))
                 country              mean_gender 
                       0                        0 
     mean_nonEU_national     mean_ethnic_minority 
                       0                        0 
 mean_skincolor_minority  mean_religious_minority 
                       0                        0 
      mean_roma_minority     mean_sexual_minority 
                       0                        0 
mean_disability_minority      mean_suffered_discr 
                       0                        0 
        mean_gender_docs          mean_trans_docs 
                       0                        0 

Now we can join the two datasets.

data_aggr <- data_num %>%
  left_join(data_dummy, by = "country")

The next variables are factor with >2 levels:

factor_names <- names(final_data)[!sapply(final_data, is.numeric) &
              !(sapply(final_data, is.factor) & sapply(final_data, function(x) length(levels(x)) == 2))]
factor_names
 [1] "country"        "community"      "marital_status"
 [4] "occupation"     "social_class"   "religion"      
 [7] "phone_access"   "bill_issues"    "internet_use"  
[10] "life_sat"       "polintr"        "left_right"    
[13] "friends_trans" 
# checking the levels
lapply(final_data[factor_names], levels)
$country
NULL

$community
[1] "Rural area or village"      "Small or middle sized town"
[3] "Large town"                

$marital_status
[1] "(Re-)Married (1-4 in d7)"              
[2] "Single living with partner (5-8 in d7)"
[3] "Single (9-10 in d7)"                   
[4] "Divorced or separated (11-12 in d7)"   
[5] "Widow (13-14 in d7)"                   

$occupation
[1] "Self-employed (5 to 9 in d15a)"        
[2] "Managers (10 to 12 in d15a)"           
[3] "Other white collars (13 or 14 in d15a)"
[4] "Manual workers (15 to 18 in d15a)"     
[5] "House persons (1 in d15a)"             
[6] "Unemployed (3 in d15a)"                
[7] "Retired (4 in d15a)"                   
[8] "Students (2 in d15a)"                  

$social_class
[1] "The working class of society"     
[2] "The lower middle class of society"
[3] "The middle class of society"      
[4] "The upper middle class of society"
[5] "The higher class of society"      

$religion
[1] "Catholic"           "Orthodox Christian" "Protestant"        
[4] "Other Christian"    "Other"              "Muslim"            
[7] "Non-believers"     

$phone_access
[1] "Mobile only"       "Landline only"     "Landline & mobile"
[4] "No telephone"     

$bill_issues
[1] "Most of the time"   "From time to time"  "Almost never/never"

$internet_use
[1] "Everyday/Almost everyday"   "Two or three times a week" 
[3] "About once a week"          "Two or three times a month"
[5] "Less often"                 "Never/No access"           
[7] "No Internet access at all" 

$life_sat
[1] "Very satisfied"       "Fairly satisfied"    
[3] "Not very satisfied"   "Not at all satisfied"

$polintr
[1] "Strong"     "Medium"     "Low"        "Not at all"

$left_right
[1] "(1 - 4) Left"   "(5 - 6) Centre" "(7 -10) Right" 

$friends_trans
[1] "Yes"                   "No"                   
[3] "Refusal (SPONTANEOUS)"
# removing country from the list
factor_names <- setdiff(factor_names, "country")

# creating the aggregated dataset for factor variables

data_factors <- final_data %>%
  select(country, all_of(factor_names)) %>%
  pivot_longer(cols = -country, names_to = "variable", values_to = "level") %>%
  group_by(country, variable, level) %>%
  summarise(count = n(), .groups = "drop") %>%
  group_by(country, variable) %>%
  mutate(proportion = count / sum(count)) %>%
  select(-count) %>%
  pivot_wider(names_from = c(variable, level), values_from = proportion, names_glue = "{variable}_{level}")

colSums(is.na(data_factors))
                                              country 
                                                    0 
                         bill_issues_Most of the time 
                                                    0 
                        bill_issues_From time to time 
                                                    0 
                       bill_issues_Almost never/never 
                                                    0 
                      community_Rural area or village 
                                                    0 
                 community_Small or middle sized town 
                                                    0 
                                 community_Large town 
                                                    0 
                                    friends_trans_Yes 
                                                    0 
                                     friends_trans_No 
                                                    0 
                  friends_trans_Refusal (SPONTANEOUS) 
                                                    0 
                internet_use_Everyday/Almost everyday 
                                                    0 
               internet_use_Two or three times a week 
                                                    0 
                       internet_use_About once a week 
                                                    1 
              internet_use_Two or three times a month 
                                                    0 
                              internet_use_Less often 
                                                    0 
                         internet_use_Never/No access 
                                                    0 
               internet_use_No Internet access at all 
                                                    0 
                              left_right_(1 - 4) Left 
                                                    0 
                            left_right_(5 - 6) Centre 
                                                    0 
                             left_right_(7 -10) Right 
                                                    0 
                              life_sat_Very satisfied 
                                                    0 
                            life_sat_Fairly satisfied 
                                                    0 
                          life_sat_Not very satisfied 
                                                    0 
                        life_sat_Not at all satisfied 
                                                    0 
              marital_status_(Re-)Married (1-4 in d7) 
                                                    0 
marital_status_Single living with partner (5-8 in d7) 
                                                    0 
                   marital_status_Single (9-10 in d7) 
                                                    0 
   marital_status_Divorced or separated (11-12 in d7) 
                                                    0 
                   marital_status_Widow (13-14 in d7) 
                                                    0 
            occupation_Self-employed (5 to 9 in d15a) 
                                                    0 
               occupation_Managers (10 to 12 in d15a) 
                                                    0 
    occupation_Other white collars (13 or 14 in d15a) 
                                                    0 
         occupation_Manual workers (15 to 18 in d15a) 
                                                    0 
                 occupation_House persons (1 in d15a) 
                                                    0 
                    occupation_Unemployed (3 in d15a) 
                                                    0 
                       occupation_Retired (4 in d15a) 
                                                    0 
                      occupation_Students (2 in d15a) 
                                                    0 
                             phone_access_Mobile only 
                                                    0 
                           phone_access_Landline only 
                                                    0 
                       phone_access_Landline & mobile 
                                                    0 
                            phone_access_No telephone 
                                                    1 
                                       polintr_Strong 
                                                    0 
                                       polintr_Medium 
                                                    0 
                                          polintr_Low 
                                                    0 
                                   polintr_Not at all 
                                                    0 
                                    religion_Catholic 
                                                    0 
                          religion_Orthodox Christian 
                                                    0 
                                  religion_Protestant 
                                                    1 
                             religion_Other Christian 
                                                    2 
                                       religion_Other 
                                                    0 
                                      religion_Muslim 
                                                    4 
                               religion_Non-believers 
                                                    0 
            social_class_The working class of society 
                                                    0 
       social_class_The lower middle class of society 
                                                    0 
             social_class_The middle class of society 
                                                    0 
       social_class_The upper middle class of society 
                                                    0 
             social_class_The higher class of society 
                                                    3 

We are seeing NAs because in not all countries are all the factors’ levels represented. For example we see that social_class_The higher class of society has 3 missing values. Let’s confirm that there are 3 countries in our dataframe with no observation for that level

final_data |> filter(social_class=="The higher class of society") |>  pull(country) |> unique() |> length()
[1] 25

Therefore those proportions should be 0s and not NAs

data_factors <- data_factors |>
  mutate(across(everything(), ~replace_na(., 0)))

Joining all together

data_aggr <- data_aggr |> 
  left_join(data_factors, by = "country")

Lastly, joining the country level variables obtained from external sources

data_aggr <- data_aggr |> 
  left_join(country_level_data, by = c("country" = "iso2c")) |> 
  select(-c(iso3c, country.y))
colSums(is.na(data_aggr))
                                              country 
                                                    0 
                                             mean_age 
                                                    0 
                                       mean_years_edu 
                                                    0 
                               mean_social_alienation 
                                                    0 
                            mean_n_friends_minorities 
                                                    0 
                        mean_n_actions_against_discri 
                                                    0 
                                mean_antilgbtq_rights 
                                                    0 
                                 mean_minority_discri 
                                                    0 
                                          mean_gender 
                                                    0 
                                  mean_nonEU_national 
                                                    0 
                                 mean_ethnic_minority 
                                                    0 
                              mean_skincolor_minority 
                                                    0 
                              mean_religious_minority 
                                                    0 
                                   mean_roma_minority 
                                                    0 
                                 mean_sexual_minority 
                                                    0 
                             mean_disability_minority 
                                                    0 
                                  mean_suffered_discr 
                                                    0 
                                     mean_gender_docs 
                                                    0 
                                      mean_trans_docs 
                                                    0 
                         bill_issues_Most of the time 
                                                    0 
                        bill_issues_From time to time 
                                                    0 
                       bill_issues_Almost never/never 
                                                    0 
                      community_Rural area or village 
                                                    0 
                 community_Small or middle sized town 
                                                    0 
                                 community_Large town 
                                                    0 
                                    friends_trans_Yes 
                                                    0 
                                     friends_trans_No 
                                                    0 
                  friends_trans_Refusal (SPONTANEOUS) 
                                                    0 
                internet_use_Everyday/Almost everyday 
                                                    0 
               internet_use_Two or three times a week 
                                                    0 
                       internet_use_About once a week 
                                                    0 
              internet_use_Two or three times a month 
                                                    0 
                              internet_use_Less often 
                                                    0 
                         internet_use_Never/No access 
                                                    0 
               internet_use_No Internet access at all 
                                                    0 
                              left_right_(1 - 4) Left 
                                                    0 
                            left_right_(5 - 6) Centre 
                                                    0 
                             left_right_(7 -10) Right 
                                                    0 
                              life_sat_Very satisfied 
                                                    0 
                            life_sat_Fairly satisfied 
                                                    0 
                          life_sat_Not very satisfied 
                                                    0 
                        life_sat_Not at all satisfied 
                                                    0 
              marital_status_(Re-)Married (1-4 in d7) 
                                                    0 
marital_status_Single living with partner (5-8 in d7) 
                                                    0 
                   marital_status_Single (9-10 in d7) 
                                                    0 
   marital_status_Divorced or separated (11-12 in d7) 
                                                    0 
                   marital_status_Widow (13-14 in d7) 
                                                    0 
            occupation_Self-employed (5 to 9 in d15a) 
                                                    0 
               occupation_Managers (10 to 12 in d15a) 
                                                    0 
    occupation_Other white collars (13 or 14 in d15a) 
                                                    0 
         occupation_Manual workers (15 to 18 in d15a) 
                                                    0 
                 occupation_House persons (1 in d15a) 
                                                    0 
                    occupation_Unemployed (3 in d15a) 
                                                    0 
                       occupation_Retired (4 in d15a) 
                                                    0 
                      occupation_Students (2 in d15a) 
                                                    0 
                             phone_access_Mobile only 
                                                    0 
                           phone_access_Landline only 
                                                    0 
                       phone_access_Landline & mobile 
                                                    0 
                            phone_access_No telephone 
                                                    0 
                                       polintr_Strong 
                                                    0 
                                       polintr_Medium 
                                                    0 
                                          polintr_Low 
                                                    0 
                                   polintr_Not at all 
                                                    0 
                                    religion_Catholic 
                                                    0 
                          religion_Orthodox Christian 
                                                    0 
                                  religion_Protestant 
                                                    0 
                             religion_Other Christian 
                                                    0 
                                       religion_Other 
                                                    0 
                                      religion_Muslim 
                                                    0 
                               religion_Non-believers 
                                                    0 
            social_class_The working class of society 
                                                    0 
       social_class_The lower middle class of society 
                                                    0 
             social_class_The middle class of society 
                                                    0 
       social_class_The upper middle class of society 
                                                    0 
             social_class_The higher class of society 
                                                    0 
                                           gdp_pc_ppp 
                                                    0 
                              gender_inequality_index 
                                                    0 
                                    lgbt_policy_index 
                                                    0 
                                      democracy_index 
                                                    0 
dim(data_aggr)
[1] 28 79

The resulting data frame has 28 observations and 79 variables. We might have to clean the names of the variables that were glued from variable_level.

Linear regression with LASSO

data_models <- data_aggr |> 
  select(-country)

# Define the leave-one-out cross-validation control
ctrl <- trainControl(
  method = "LOOCV",
  verboseIter = TRUE
)

# # LASSO
# # Set up the grid of lambda values for Lasso
# lambda_grid <- 10^seq(-3, 3, length = 100)
# 
# # Train the Lasso model with LOOCV
# lasso_model <- train(
#   mean_trans_docs ~ ., 
#   data = data_models, 
#   method = "glmnet",
#   preProc=c('scale','center'),
#   trControl = ctrl,
#   tuneGrid = expand.grid(
#     alpha = 1,  # 1 for Lasso
#     lambda = lambda_grid
#   ),
#   importance = TRUE,
#   metric = "RMSE"
# )
# # Print the best tuning parameter (lambda)
# print(lasso_model$bestTune)
# 
# # Summarize the final model
# print(lasso_model)
# 
# # Examine variable importance
# importance <- varImp(lasso_model, scale = FALSE)
# print(importance)
# plot(importance, top = 20)
# 
# # Get the coefficients of the best model
# best_model <- lasso_model$finalModel
# coef_lasso <- coef(best_model, s = best_lambda)
# print(coef_lasso)


# ELASTIC 
elastic_grid <- expand.grid(
  alpha = seq(0, 1, length = 10),  # Search from Ridge (0) to Lasso (1)
  lambda = 10^seq(-3, 3, length = 100)  # Regularization strength
)

# Train the Elastic Net model
elastic_net_model <- train(
  mean_trans_docs ~ ., 
  data = data_models, 
  method = "glmnet",
  preProcess = c("center", "scale"),
  trControl = ctrl,
  tuneGrid = elastic_grid,
  metric = "RMSE"
)
+ Fold01: alpha=0.0000000, lambda=1000 
- Fold01: alpha=0.0000000, lambda=1000 
+ Fold01: alpha=0.1111111, lambda=1000 
- Fold01: alpha=0.1111111, lambda=1000 
+ Fold01: alpha=0.2222222, lambda=1000 
- Fold01: alpha=0.2222222, lambda=1000 
+ Fold01: alpha=0.3333333, lambda=1000 
- Fold01: alpha=0.3333333, lambda=1000 
+ Fold01: alpha=0.4444444, lambda=1000 
- Fold01: alpha=0.4444444, lambda=1000 
+ Fold01: alpha=0.5555556, lambda=1000 
- Fold01: alpha=0.5555556, lambda=1000 
+ Fold01: alpha=0.6666667, lambda=1000 
- Fold01: alpha=0.6666667, lambda=1000 
+ Fold01: alpha=0.7777778, lambda=1000 
- Fold01: alpha=0.7777778, lambda=1000 
+ Fold01: alpha=0.8888889, lambda=1000 
- Fold01: alpha=0.8888889, lambda=1000 
+ Fold01: alpha=1.0000000, lambda=1000 
- Fold01: alpha=1.0000000, lambda=1000 
+ Fold02: alpha=0.0000000, lambda=1000 
- Fold02: alpha=0.0000000, lambda=1000 
+ Fold02: alpha=0.1111111, lambda=1000 
- Fold02: alpha=0.1111111, lambda=1000 
+ Fold02: alpha=0.2222222, lambda=1000 
- Fold02: alpha=0.2222222, lambda=1000 
+ Fold02: alpha=0.3333333, lambda=1000 
- Fold02: alpha=0.3333333, lambda=1000 
+ Fold02: alpha=0.4444444, lambda=1000 
- Fold02: alpha=0.4444444, lambda=1000 
+ Fold02: alpha=0.5555556, lambda=1000 
- Fold02: alpha=0.5555556, lambda=1000 
+ Fold02: alpha=0.6666667, lambda=1000 
- Fold02: alpha=0.6666667, lambda=1000 
+ Fold02: alpha=0.7777778, lambda=1000 
- Fold02: alpha=0.7777778, lambda=1000 
+ Fold02: alpha=0.8888889, lambda=1000 
- Fold02: alpha=0.8888889, lambda=1000 
+ Fold02: alpha=1.0000000, lambda=1000 
- Fold02: alpha=1.0000000, lambda=1000 
+ Fold03: alpha=0.0000000, lambda=1000 
- Fold03: alpha=0.0000000, lambda=1000 
+ Fold03: alpha=0.1111111, lambda=1000 
- Fold03: alpha=0.1111111, lambda=1000 
+ Fold03: alpha=0.2222222, lambda=1000 
- Fold03: alpha=0.2222222, lambda=1000 
+ Fold03: alpha=0.3333333, lambda=1000 
- Fold03: alpha=0.3333333, lambda=1000 
+ Fold03: alpha=0.4444444, lambda=1000 
- Fold03: alpha=0.4444444, lambda=1000 
+ Fold03: alpha=0.5555556, lambda=1000 
- Fold03: alpha=0.5555556, lambda=1000 
+ Fold03: alpha=0.6666667, lambda=1000 
- Fold03: alpha=0.6666667, lambda=1000 
+ Fold03: alpha=0.7777778, lambda=1000 
- Fold03: alpha=0.7777778, lambda=1000 
+ Fold03: alpha=0.8888889, lambda=1000 
- Fold03: alpha=0.8888889, lambda=1000 
+ Fold03: alpha=1.0000000, lambda=1000 
- Fold03: alpha=1.0000000, lambda=1000 
+ Fold04: alpha=0.0000000, lambda=1000 
- Fold04: alpha=0.0000000, lambda=1000 
+ Fold04: alpha=0.1111111, lambda=1000 
- Fold04: alpha=0.1111111, lambda=1000 
+ Fold04: alpha=0.2222222, lambda=1000 
- Fold04: alpha=0.2222222, lambda=1000 
+ Fold04: alpha=0.3333333, lambda=1000 
- Fold04: alpha=0.3333333, lambda=1000 
+ Fold04: alpha=0.4444444, lambda=1000 
- Fold04: alpha=0.4444444, lambda=1000 
+ Fold04: alpha=0.5555556, lambda=1000 
- Fold04: alpha=0.5555556, lambda=1000 
+ Fold04: alpha=0.6666667, lambda=1000 
- Fold04: alpha=0.6666667, lambda=1000 
+ Fold04: alpha=0.7777778, lambda=1000 
- Fold04: alpha=0.7777778, lambda=1000 
+ Fold04: alpha=0.8888889, lambda=1000 
- Fold04: alpha=0.8888889, lambda=1000 
+ Fold04: alpha=1.0000000, lambda=1000 
- Fold04: alpha=1.0000000, lambda=1000 
+ Fold05: alpha=0.0000000, lambda=1000 
- Fold05: alpha=0.0000000, lambda=1000 
+ Fold05: alpha=0.1111111, lambda=1000 
- Fold05: alpha=0.1111111, lambda=1000 
+ Fold05: alpha=0.2222222, lambda=1000 
- Fold05: alpha=0.2222222, lambda=1000 
+ Fold05: alpha=0.3333333, lambda=1000 
- Fold05: alpha=0.3333333, lambda=1000 
+ Fold05: alpha=0.4444444, lambda=1000 
- Fold05: alpha=0.4444444, lambda=1000 
+ Fold05: alpha=0.5555556, lambda=1000 
- Fold05: alpha=0.5555556, lambda=1000 
+ Fold05: alpha=0.6666667, lambda=1000 
- Fold05: alpha=0.6666667, lambda=1000 
+ Fold05: alpha=0.7777778, lambda=1000 
- Fold05: alpha=0.7777778, lambda=1000 
+ Fold05: alpha=0.8888889, lambda=1000 
- Fold05: alpha=0.8888889, lambda=1000 
+ Fold05: alpha=1.0000000, lambda=1000 
- Fold05: alpha=1.0000000, lambda=1000 
+ Fold06: alpha=0.0000000, lambda=1000 
- Fold06: alpha=0.0000000, lambda=1000 
+ Fold06: alpha=0.1111111, lambda=1000 
- Fold06: alpha=0.1111111, lambda=1000 
+ Fold06: alpha=0.2222222, lambda=1000 
- Fold06: alpha=0.2222222, lambda=1000 
+ Fold06: alpha=0.3333333, lambda=1000 
- Fold06: alpha=0.3333333, lambda=1000 
+ Fold06: alpha=0.4444444, lambda=1000 
- Fold06: alpha=0.4444444, lambda=1000 
+ Fold06: alpha=0.5555556, lambda=1000 
- Fold06: alpha=0.5555556, lambda=1000 
+ Fold06: alpha=0.6666667, lambda=1000 
- Fold06: alpha=0.6666667, lambda=1000 
+ Fold06: alpha=0.7777778, lambda=1000 
- Fold06: alpha=0.7777778, lambda=1000 
+ Fold06: alpha=0.8888889, lambda=1000 
- Fold06: alpha=0.8888889, lambda=1000 
+ Fold06: alpha=1.0000000, lambda=1000 
- Fold06: alpha=1.0000000, lambda=1000 
+ Fold07: alpha=0.0000000, lambda=1000 
- Fold07: alpha=0.0000000, lambda=1000 
+ Fold07: alpha=0.1111111, lambda=1000 
- Fold07: alpha=0.1111111, lambda=1000 
+ Fold07: alpha=0.2222222, lambda=1000 
- Fold07: alpha=0.2222222, lambda=1000 
+ Fold07: alpha=0.3333333, lambda=1000 
- Fold07: alpha=0.3333333, lambda=1000 
+ Fold07: alpha=0.4444444, lambda=1000 
- Fold07: alpha=0.4444444, lambda=1000 
+ Fold07: alpha=0.5555556, lambda=1000 
- Fold07: alpha=0.5555556, lambda=1000 
+ Fold07: alpha=0.6666667, lambda=1000 
- Fold07: alpha=0.6666667, lambda=1000 
+ Fold07: alpha=0.7777778, lambda=1000 
- Fold07: alpha=0.7777778, lambda=1000 
+ Fold07: alpha=0.8888889, lambda=1000 
- Fold07: alpha=0.8888889, lambda=1000 
+ Fold07: alpha=1.0000000, lambda=1000 
- Fold07: alpha=1.0000000, lambda=1000 
+ Fold08: alpha=0.0000000, lambda=1000 
- Fold08: alpha=0.0000000, lambda=1000 
+ Fold08: alpha=0.1111111, lambda=1000 
- Fold08: alpha=0.1111111, lambda=1000 
+ Fold08: alpha=0.2222222, lambda=1000 
- Fold08: alpha=0.2222222, lambda=1000 
+ Fold08: alpha=0.3333333, lambda=1000 
- Fold08: alpha=0.3333333, lambda=1000 
+ Fold08: alpha=0.4444444, lambda=1000 
- Fold08: alpha=0.4444444, lambda=1000 
+ Fold08: alpha=0.5555556, lambda=1000 
- Fold08: alpha=0.5555556, lambda=1000 
+ Fold08: alpha=0.6666667, lambda=1000 
- Fold08: alpha=0.6666667, lambda=1000 
+ Fold08: alpha=0.7777778, lambda=1000 
- Fold08: alpha=0.7777778, lambda=1000 
+ Fold08: alpha=0.8888889, lambda=1000 
- Fold08: alpha=0.8888889, lambda=1000 
+ Fold08: alpha=1.0000000, lambda=1000 
- Fold08: alpha=1.0000000, lambda=1000 
+ Fold09: alpha=0.0000000, lambda=1000 
- Fold09: alpha=0.0000000, lambda=1000 
+ Fold09: alpha=0.1111111, lambda=1000 
- Fold09: alpha=0.1111111, lambda=1000 
+ Fold09: alpha=0.2222222, lambda=1000 
- Fold09: alpha=0.2222222, lambda=1000 
+ Fold09: alpha=0.3333333, lambda=1000 
- Fold09: alpha=0.3333333, lambda=1000 
+ Fold09: alpha=0.4444444, lambda=1000 
- Fold09: alpha=0.4444444, lambda=1000 
+ Fold09: alpha=0.5555556, lambda=1000 
- Fold09: alpha=0.5555556, lambda=1000 
+ Fold09: alpha=0.6666667, lambda=1000 
- Fold09: alpha=0.6666667, lambda=1000 
+ Fold09: alpha=0.7777778, lambda=1000 
- Fold09: alpha=0.7777778, lambda=1000 
+ Fold09: alpha=0.8888889, lambda=1000 
- Fold09: alpha=0.8888889, lambda=1000 
+ Fold09: alpha=1.0000000, lambda=1000 
- Fold09: alpha=1.0000000, lambda=1000 
+ Fold10: alpha=0.0000000, lambda=1000 
- Fold10: alpha=0.0000000, lambda=1000 
+ Fold10: alpha=0.1111111, lambda=1000 
- Fold10: alpha=0.1111111, lambda=1000 
+ Fold10: alpha=0.2222222, lambda=1000 
- Fold10: alpha=0.2222222, lambda=1000 
+ Fold10: alpha=0.3333333, lambda=1000 
- Fold10: alpha=0.3333333, lambda=1000 
+ Fold10: alpha=0.4444444, lambda=1000 
- Fold10: alpha=0.4444444, lambda=1000 
+ Fold10: alpha=0.5555556, lambda=1000 
- Fold10: alpha=0.5555556, lambda=1000 
+ Fold10: alpha=0.6666667, lambda=1000 
- Fold10: alpha=0.6666667, lambda=1000 
+ Fold10: alpha=0.7777778, lambda=1000 
- Fold10: alpha=0.7777778, lambda=1000 
+ Fold10: alpha=0.8888889, lambda=1000 
- Fold10: alpha=0.8888889, lambda=1000 
+ Fold10: alpha=1.0000000, lambda=1000 
- Fold10: alpha=1.0000000, lambda=1000 
+ Fold11: alpha=0.0000000, lambda=1000 
- Fold11: alpha=0.0000000, lambda=1000 
+ Fold11: alpha=0.1111111, lambda=1000 
- Fold11: alpha=0.1111111, lambda=1000 
+ Fold11: alpha=0.2222222, lambda=1000 
- Fold11: alpha=0.2222222, lambda=1000 
+ Fold11: alpha=0.3333333, lambda=1000 
- Fold11: alpha=0.3333333, lambda=1000 
+ Fold11: alpha=0.4444444, lambda=1000 
- Fold11: alpha=0.4444444, lambda=1000 
+ Fold11: alpha=0.5555556, lambda=1000 
- Fold11: alpha=0.5555556, lambda=1000 
+ Fold11: alpha=0.6666667, lambda=1000 
- Fold11: alpha=0.6666667, lambda=1000 
+ Fold11: alpha=0.7777778, lambda=1000 
- Fold11: alpha=0.7777778, lambda=1000 
+ Fold11: alpha=0.8888889, lambda=1000 
- Fold11: alpha=0.8888889, lambda=1000 
+ Fold11: alpha=1.0000000, lambda=1000 
- Fold11: alpha=1.0000000, lambda=1000 
+ Fold12: alpha=0.0000000, lambda=1000 
- Fold12: alpha=0.0000000, lambda=1000 
+ Fold12: alpha=0.1111111, lambda=1000 
- Fold12: alpha=0.1111111, lambda=1000 
+ Fold12: alpha=0.2222222, lambda=1000 
- Fold12: alpha=0.2222222, lambda=1000 
+ Fold12: alpha=0.3333333, lambda=1000 
- Fold12: alpha=0.3333333, lambda=1000 
+ Fold12: alpha=0.4444444, lambda=1000 
- Fold12: alpha=0.4444444, lambda=1000 
+ Fold12: alpha=0.5555556, lambda=1000 
- Fold12: alpha=0.5555556, lambda=1000 
+ Fold12: alpha=0.6666667, lambda=1000 
- Fold12: alpha=0.6666667, lambda=1000 
+ Fold12: alpha=0.7777778, lambda=1000 
- Fold12: alpha=0.7777778, lambda=1000 
+ Fold12: alpha=0.8888889, lambda=1000 
- Fold12: alpha=0.8888889, lambda=1000 
+ Fold12: alpha=1.0000000, lambda=1000 
- Fold12: alpha=1.0000000, lambda=1000 
+ Fold13: alpha=0.0000000, lambda=1000 
- Fold13: alpha=0.0000000, lambda=1000 
+ Fold13: alpha=0.1111111, lambda=1000 
- Fold13: alpha=0.1111111, lambda=1000 
+ Fold13: alpha=0.2222222, lambda=1000 
- Fold13: alpha=0.2222222, lambda=1000 
+ Fold13: alpha=0.3333333, lambda=1000 
- Fold13: alpha=0.3333333, lambda=1000 
+ Fold13: alpha=0.4444444, lambda=1000 
- Fold13: alpha=0.4444444, lambda=1000 
+ Fold13: alpha=0.5555556, lambda=1000 
- Fold13: alpha=0.5555556, lambda=1000 
+ Fold13: alpha=0.6666667, lambda=1000 
- Fold13: alpha=0.6666667, lambda=1000 
+ Fold13: alpha=0.7777778, lambda=1000 
- Fold13: alpha=0.7777778, lambda=1000 
+ Fold13: alpha=0.8888889, lambda=1000 
- Fold13: alpha=0.8888889, lambda=1000 
+ Fold13: alpha=1.0000000, lambda=1000 
- Fold13: alpha=1.0000000, lambda=1000 
+ Fold14: alpha=0.0000000, lambda=1000 
- Fold14: alpha=0.0000000, lambda=1000 
+ Fold14: alpha=0.1111111, lambda=1000 
- Fold14: alpha=0.1111111, lambda=1000 
+ Fold14: alpha=0.2222222, lambda=1000 
- Fold14: alpha=0.2222222, lambda=1000 
+ Fold14: alpha=0.3333333, lambda=1000 
- Fold14: alpha=0.3333333, lambda=1000 
+ Fold14: alpha=0.4444444, lambda=1000 
- Fold14: alpha=0.4444444, lambda=1000 
+ Fold14: alpha=0.5555556, lambda=1000 
- Fold14: alpha=0.5555556, lambda=1000 
+ Fold14: alpha=0.6666667, lambda=1000 
- Fold14: alpha=0.6666667, lambda=1000 
+ Fold14: alpha=0.7777778, lambda=1000 
- Fold14: alpha=0.7777778, lambda=1000 
+ Fold14: alpha=0.8888889, lambda=1000 
- Fold14: alpha=0.8888889, lambda=1000 
+ Fold14: alpha=1.0000000, lambda=1000 
- Fold14: alpha=1.0000000, lambda=1000 
+ Fold15: alpha=0.0000000, lambda=1000 
- Fold15: alpha=0.0000000, lambda=1000 
+ Fold15: alpha=0.1111111, lambda=1000 
- Fold15: alpha=0.1111111, lambda=1000 
+ Fold15: alpha=0.2222222, lambda=1000 
- Fold15: alpha=0.2222222, lambda=1000 
+ Fold15: alpha=0.3333333, lambda=1000 
- Fold15: alpha=0.3333333, lambda=1000 
+ Fold15: alpha=0.4444444, lambda=1000 
- Fold15: alpha=0.4444444, lambda=1000 
+ Fold15: alpha=0.5555556, lambda=1000 
- Fold15: alpha=0.5555556, lambda=1000 
+ Fold15: alpha=0.6666667, lambda=1000 
- Fold15: alpha=0.6666667, lambda=1000 
+ Fold15: alpha=0.7777778, lambda=1000 
- Fold15: alpha=0.7777778, lambda=1000 
+ Fold15: alpha=0.8888889, lambda=1000 
- Fold15: alpha=0.8888889, lambda=1000 
+ Fold15: alpha=1.0000000, lambda=1000 
- Fold15: alpha=1.0000000, lambda=1000 
+ Fold16: alpha=0.0000000, lambda=1000 
- Fold16: alpha=0.0000000, lambda=1000 
+ Fold16: alpha=0.1111111, lambda=1000 
- Fold16: alpha=0.1111111, lambda=1000 
+ Fold16: alpha=0.2222222, lambda=1000 
- Fold16: alpha=0.2222222, lambda=1000 
+ Fold16: alpha=0.3333333, lambda=1000 
- Fold16: alpha=0.3333333, lambda=1000 
+ Fold16: alpha=0.4444444, lambda=1000 
- Fold16: alpha=0.4444444, lambda=1000 
+ Fold16: alpha=0.5555556, lambda=1000 
- Fold16: alpha=0.5555556, lambda=1000 
+ Fold16: alpha=0.6666667, lambda=1000 
- Fold16: alpha=0.6666667, lambda=1000 
+ Fold16: alpha=0.7777778, lambda=1000 
- Fold16: alpha=0.7777778, lambda=1000 
+ Fold16: alpha=0.8888889, lambda=1000 
- Fold16: alpha=0.8888889, lambda=1000 
+ Fold16: alpha=1.0000000, lambda=1000 
- Fold16: alpha=1.0000000, lambda=1000 
+ Fold17: alpha=0.0000000, lambda=1000 
- Fold17: alpha=0.0000000, lambda=1000 
+ Fold17: alpha=0.1111111, lambda=1000 
- Fold17: alpha=0.1111111, lambda=1000 
+ Fold17: alpha=0.2222222, lambda=1000 
- Fold17: alpha=0.2222222, lambda=1000 
+ Fold17: alpha=0.3333333, lambda=1000 
- Fold17: alpha=0.3333333, lambda=1000 
+ Fold17: alpha=0.4444444, lambda=1000 
- Fold17: alpha=0.4444444, lambda=1000 
+ Fold17: alpha=0.5555556, lambda=1000 
- Fold17: alpha=0.5555556, lambda=1000 
+ Fold17: alpha=0.6666667, lambda=1000 
- Fold17: alpha=0.6666667, lambda=1000 
+ Fold17: alpha=0.7777778, lambda=1000 
- Fold17: alpha=0.7777778, lambda=1000 
+ Fold17: alpha=0.8888889, lambda=1000 
- Fold17: alpha=0.8888889, lambda=1000 
+ Fold17: alpha=1.0000000, lambda=1000 
- Fold17: alpha=1.0000000, lambda=1000 
+ Fold18: alpha=0.0000000, lambda=1000 
- Fold18: alpha=0.0000000, lambda=1000 
+ Fold18: alpha=0.1111111, lambda=1000 
- Fold18: alpha=0.1111111, lambda=1000 
+ Fold18: alpha=0.2222222, lambda=1000 
- Fold18: alpha=0.2222222, lambda=1000 
+ Fold18: alpha=0.3333333, lambda=1000 
- Fold18: alpha=0.3333333, lambda=1000 
+ Fold18: alpha=0.4444444, lambda=1000 
- Fold18: alpha=0.4444444, lambda=1000 
+ Fold18: alpha=0.5555556, lambda=1000 
- Fold18: alpha=0.5555556, lambda=1000 
+ Fold18: alpha=0.6666667, lambda=1000 
- Fold18: alpha=0.6666667, lambda=1000 
+ Fold18: alpha=0.7777778, lambda=1000 
- Fold18: alpha=0.7777778, lambda=1000 
+ Fold18: alpha=0.8888889, lambda=1000 
- Fold18: alpha=0.8888889, lambda=1000 
+ Fold18: alpha=1.0000000, lambda=1000 
- Fold18: alpha=1.0000000, lambda=1000 
+ Fold19: alpha=0.0000000, lambda=1000 
- Fold19: alpha=0.0000000, lambda=1000 
+ Fold19: alpha=0.1111111, lambda=1000 
- Fold19: alpha=0.1111111, lambda=1000 
+ Fold19: alpha=0.2222222, lambda=1000 
- Fold19: alpha=0.2222222, lambda=1000 
+ Fold19: alpha=0.3333333, lambda=1000 
- Fold19: alpha=0.3333333, lambda=1000 
+ Fold19: alpha=0.4444444, lambda=1000 
- Fold19: alpha=0.4444444, lambda=1000 
+ Fold19: alpha=0.5555556, lambda=1000 
- Fold19: alpha=0.5555556, lambda=1000 
+ Fold19: alpha=0.6666667, lambda=1000 
- Fold19: alpha=0.6666667, lambda=1000 
+ Fold19: alpha=0.7777778, lambda=1000 
- Fold19: alpha=0.7777778, lambda=1000 
+ Fold19: alpha=0.8888889, lambda=1000 
- Fold19: alpha=0.8888889, lambda=1000 
+ Fold19: alpha=1.0000000, lambda=1000 
- Fold19: alpha=1.0000000, lambda=1000 
+ Fold20: alpha=0.0000000, lambda=1000 
- Fold20: alpha=0.0000000, lambda=1000 
+ Fold20: alpha=0.1111111, lambda=1000 
- Fold20: alpha=0.1111111, lambda=1000 
+ Fold20: alpha=0.2222222, lambda=1000 
- Fold20: alpha=0.2222222, lambda=1000 
+ Fold20: alpha=0.3333333, lambda=1000 
- Fold20: alpha=0.3333333, lambda=1000 
+ Fold20: alpha=0.4444444, lambda=1000 
- Fold20: alpha=0.4444444, lambda=1000 
+ Fold20: alpha=0.5555556, lambda=1000 
- Fold20: alpha=0.5555556, lambda=1000 
+ Fold20: alpha=0.6666667, lambda=1000 
- Fold20: alpha=0.6666667, lambda=1000 
+ Fold20: alpha=0.7777778, lambda=1000 
- Fold20: alpha=0.7777778, lambda=1000 
+ Fold20: alpha=0.8888889, lambda=1000 
- Fold20: alpha=0.8888889, lambda=1000 
+ Fold20: alpha=1.0000000, lambda=1000 
- Fold20: alpha=1.0000000, lambda=1000 
+ Fold21: alpha=0.0000000, lambda=1000 
- Fold21: alpha=0.0000000, lambda=1000 
+ Fold21: alpha=0.1111111, lambda=1000 
- Fold21: alpha=0.1111111, lambda=1000 
+ Fold21: alpha=0.2222222, lambda=1000 
- Fold21: alpha=0.2222222, lambda=1000 
+ Fold21: alpha=0.3333333, lambda=1000 
- Fold21: alpha=0.3333333, lambda=1000 
+ Fold21: alpha=0.4444444, lambda=1000 
- Fold21: alpha=0.4444444, lambda=1000 
+ Fold21: alpha=0.5555556, lambda=1000 
- Fold21: alpha=0.5555556, lambda=1000 
+ Fold21: alpha=0.6666667, lambda=1000 
- Fold21: alpha=0.6666667, lambda=1000 
+ Fold21: alpha=0.7777778, lambda=1000 
- Fold21: alpha=0.7777778, lambda=1000 
+ Fold21: alpha=0.8888889, lambda=1000 
- Fold21: alpha=0.8888889, lambda=1000 
+ Fold21: alpha=1.0000000, lambda=1000 
- Fold21: alpha=1.0000000, lambda=1000 
+ Fold22: alpha=0.0000000, lambda=1000 
- Fold22: alpha=0.0000000, lambda=1000 
+ Fold22: alpha=0.1111111, lambda=1000 
- Fold22: alpha=0.1111111, lambda=1000 
+ Fold22: alpha=0.2222222, lambda=1000 
- Fold22: alpha=0.2222222, lambda=1000 
+ Fold22: alpha=0.3333333, lambda=1000 
- Fold22: alpha=0.3333333, lambda=1000 
+ Fold22: alpha=0.4444444, lambda=1000 
- Fold22: alpha=0.4444444, lambda=1000 
+ Fold22: alpha=0.5555556, lambda=1000 
- Fold22: alpha=0.5555556, lambda=1000 
+ Fold22: alpha=0.6666667, lambda=1000 
- Fold22: alpha=0.6666667, lambda=1000 
+ Fold22: alpha=0.7777778, lambda=1000 
- Fold22: alpha=0.7777778, lambda=1000 
+ Fold22: alpha=0.8888889, lambda=1000 
- Fold22: alpha=0.8888889, lambda=1000 
+ Fold22: alpha=1.0000000, lambda=1000 
- Fold22: alpha=1.0000000, lambda=1000 
+ Fold23: alpha=0.0000000, lambda=1000 
- Fold23: alpha=0.0000000, lambda=1000 
+ Fold23: alpha=0.1111111, lambda=1000 
- Fold23: alpha=0.1111111, lambda=1000 
+ Fold23: alpha=0.2222222, lambda=1000 
- Fold23: alpha=0.2222222, lambda=1000 
+ Fold23: alpha=0.3333333, lambda=1000 
- Fold23: alpha=0.3333333, lambda=1000 
+ Fold23: alpha=0.4444444, lambda=1000 
- Fold23: alpha=0.4444444, lambda=1000 
+ Fold23: alpha=0.5555556, lambda=1000 
- Fold23: alpha=0.5555556, lambda=1000 
+ Fold23: alpha=0.6666667, lambda=1000 
- Fold23: alpha=0.6666667, lambda=1000 
+ Fold23: alpha=0.7777778, lambda=1000 
- Fold23: alpha=0.7777778, lambda=1000 
+ Fold23: alpha=0.8888889, lambda=1000 
- Fold23: alpha=0.8888889, lambda=1000 
+ Fold23: alpha=1.0000000, lambda=1000 
- Fold23: alpha=1.0000000, lambda=1000 
+ Fold24: alpha=0.0000000, lambda=1000 
- Fold24: alpha=0.0000000, lambda=1000 
+ Fold24: alpha=0.1111111, lambda=1000 
- Fold24: alpha=0.1111111, lambda=1000 
+ Fold24: alpha=0.2222222, lambda=1000 
- Fold24: alpha=0.2222222, lambda=1000 
+ Fold24: alpha=0.3333333, lambda=1000 
- Fold24: alpha=0.3333333, lambda=1000 
+ Fold24: alpha=0.4444444, lambda=1000 
- Fold24: alpha=0.4444444, lambda=1000 
+ Fold24: alpha=0.5555556, lambda=1000 
- Fold24: alpha=0.5555556, lambda=1000 
+ Fold24: alpha=0.6666667, lambda=1000 
- Fold24: alpha=0.6666667, lambda=1000 
+ Fold24: alpha=0.7777778, lambda=1000 
- Fold24: alpha=0.7777778, lambda=1000 
+ Fold24: alpha=0.8888889, lambda=1000 
- Fold24: alpha=0.8888889, lambda=1000 
+ Fold24: alpha=1.0000000, lambda=1000 
- Fold24: alpha=1.0000000, lambda=1000 
+ Fold25: alpha=0.0000000, lambda=1000 
- Fold25: alpha=0.0000000, lambda=1000 
+ Fold25: alpha=0.1111111, lambda=1000 
- Fold25: alpha=0.1111111, lambda=1000 
+ Fold25: alpha=0.2222222, lambda=1000 
- Fold25: alpha=0.2222222, lambda=1000 
+ Fold25: alpha=0.3333333, lambda=1000 
- Fold25: alpha=0.3333333, lambda=1000 
+ Fold25: alpha=0.4444444, lambda=1000 
- Fold25: alpha=0.4444444, lambda=1000 
+ Fold25: alpha=0.5555556, lambda=1000 
- Fold25: alpha=0.5555556, lambda=1000 
+ Fold25: alpha=0.6666667, lambda=1000 
- Fold25: alpha=0.6666667, lambda=1000 
+ Fold25: alpha=0.7777778, lambda=1000 
- Fold25: alpha=0.7777778, lambda=1000 
+ Fold25: alpha=0.8888889, lambda=1000 
- Fold25: alpha=0.8888889, lambda=1000 
+ Fold25: alpha=1.0000000, lambda=1000 
- Fold25: alpha=1.0000000, lambda=1000 
+ Fold26: alpha=0.0000000, lambda=1000 
- Fold26: alpha=0.0000000, lambda=1000 
+ Fold26: alpha=0.1111111, lambda=1000 
- Fold26: alpha=0.1111111, lambda=1000 
+ Fold26: alpha=0.2222222, lambda=1000 
- Fold26: alpha=0.2222222, lambda=1000 
+ Fold26: alpha=0.3333333, lambda=1000 
- Fold26: alpha=0.3333333, lambda=1000 
+ Fold26: alpha=0.4444444, lambda=1000 
- Fold26: alpha=0.4444444, lambda=1000 
+ Fold26: alpha=0.5555556, lambda=1000 
- Fold26: alpha=0.5555556, lambda=1000 
+ Fold26: alpha=0.6666667, lambda=1000 
- Fold26: alpha=0.6666667, lambda=1000 
+ Fold26: alpha=0.7777778, lambda=1000 
- Fold26: alpha=0.7777778, lambda=1000 
+ Fold26: alpha=0.8888889, lambda=1000 
- Fold26: alpha=0.8888889, lambda=1000 
+ Fold26: alpha=1.0000000, lambda=1000 
- Fold26: alpha=1.0000000, lambda=1000 
+ Fold27: alpha=0.0000000, lambda=1000 
- Fold27: alpha=0.0000000, lambda=1000 
+ Fold27: alpha=0.1111111, lambda=1000 
- Fold27: alpha=0.1111111, lambda=1000 
+ Fold27: alpha=0.2222222, lambda=1000 
- Fold27: alpha=0.2222222, lambda=1000 
+ Fold27: alpha=0.3333333, lambda=1000 
- Fold27: alpha=0.3333333, lambda=1000 
+ Fold27: alpha=0.4444444, lambda=1000 
- Fold27: alpha=0.4444444, lambda=1000 
+ Fold27: alpha=0.5555556, lambda=1000 
- Fold27: alpha=0.5555556, lambda=1000 
+ Fold27: alpha=0.6666667, lambda=1000 
- Fold27: alpha=0.6666667, lambda=1000 
+ Fold27: alpha=0.7777778, lambda=1000 
- Fold27: alpha=0.7777778, lambda=1000 
+ Fold27: alpha=0.8888889, lambda=1000 
- Fold27: alpha=0.8888889, lambda=1000 
+ Fold27: alpha=1.0000000, lambda=1000 
- Fold27: alpha=1.0000000, lambda=1000 
+ Fold28: alpha=0.0000000, lambda=1000 
- Fold28: alpha=0.0000000, lambda=1000 
+ Fold28: alpha=0.1111111, lambda=1000 
- Fold28: alpha=0.1111111, lambda=1000 
+ Fold28: alpha=0.2222222, lambda=1000 
- Fold28: alpha=0.2222222, lambda=1000 
+ Fold28: alpha=0.3333333, lambda=1000 
- Fold28: alpha=0.3333333, lambda=1000 
+ Fold28: alpha=0.4444444, lambda=1000 
- Fold28: alpha=0.4444444, lambda=1000 
+ Fold28: alpha=0.5555556, lambda=1000 
- Fold28: alpha=0.5555556, lambda=1000 
+ Fold28: alpha=0.6666667, lambda=1000 
- Fold28: alpha=0.6666667, lambda=1000 
+ Fold28: alpha=0.7777778, lambda=1000 
- Fold28: alpha=0.7777778, lambda=1000 
+ Fold28: alpha=0.8888889, lambda=1000 
- Fold28: alpha=0.8888889, lambda=1000 
+ Fold28: alpha=1.0000000, lambda=1000 
- Fold28: alpha=1.0000000, lambda=1000 
Aggregating results
Selecting tuning parameters
Fitting alpha = 0.778, lambda = 0.0215 on full training set
# Display the best alpha and lambda values
print(elastic_net_model$bestTune)
        alpha     lambda
723 0.7777778 0.02154435
# Plot the results to see the optimal alpha and lambda
plot(elastic_net_model)
# Make predictions on the dataset
predictions <- predict(elastic_net_model, newdata = data_models)

# Evaluate model performance
mse <- mean((predictions - data_models$mean_trans_docs)^2)
r_squared <- 1 - sum((predictions - data_models$mean_trans_docs)^2) / sum((data_models$mean_trans_docs - mean(data_models$mean_trans_docs))^2)

# Print evaluation metrics
print(paste("MSE:", mse))
[1] "MSE: 0.00227648789058555"
print(paste("R-squared:", r_squared))
[1] "R-squared: 0.946905167042649"
Commented bc I moved predictions to the last part.
# # Calculate predictions and residuals
# predictions <- predict(lasso_model, data_models)
# # Extract the actual values
# actual <- data_models$mean_trans_docs
# # Calculate residuals
# residuals <- actual - predictions
# 
# 
# # Calculate R-squared and RMSE
# r_squared <- 1 - sum(residuals^2) / sum((actual - mean(actual))^2)
# rmse <- sqrt(mean(residuals^2))
# 
# 
# cat("R-squared:", r_squared, "\n")
# cat("RMSE:", rmse, "\n")
# 
# # Plot actual vs predicted values
# plot(actual, predictions, 
#      main = "Actual vs Predicted Values",
#      xlab = "Actual", ylab = "Predicted",
#      pch = 16, col = "blue")
# abline(0, 1, col = "red")
# 
# # Plot residuals
# plot(predictions, residuals,
#      main = "Residuals vs Predicted Values",
#      xlab = "Predicted Values", ylab = "Residuals",
#      pch = 16, col = "blue")
# abline(h = 0, col = "red")
# 
# # Combine country names with predictions
# country_predictions <- data.frame(
#   country = data_aggr$country,
#   actual = target,
#   predicted = predictions
# )
# 
# # Sort by prediction (descending)
# country_predictions <- country_predictions[order(country_predictions$predicted, decreasing = TRUE), ]
# print(country_predictions)

Random forest

# I CHANGED THE DATA USED TO DATA_MODELS SO I COULD KEEP THE COUNTRY COLUMN FOR PREDICTIONS

# data_aggr <- data_aggr |> 
#   select(-country)

# Define LOOCV control
control <- trainControl(
  method = "LOOCV",
  verboseIter = TRUE,  # Print progress
  returnResamp = "all" # Save all resampling results
)

# Define hyperparameter grid for Random Forest
rf_grid <- expand.grid(
  mtry = seq(2, ncol(data_models) - 1, by = 2)
)
# mtry the number of variables randomly sampled at each split

# Train Random Forest model with hyperparameter tuning
rf_model <- train(
  mean_trans_docs ~ ., 
  data = data_models, 
  method = "rf",
  preProc=c('scale','center'),
  trControl = control,
  tuneGrid = rf_grid,
  importance = TRUE   # Calculate variable importance
)
+ Fold01: mtry= 2 
- Fold01: mtry= 2 
+ Fold01: mtry= 4 
- Fold01: mtry= 4 
+ Fold01: mtry= 6 
- Fold01: mtry= 6 
+ Fold01: mtry= 8 
- Fold01: mtry= 8 
+ Fold01: mtry=10 
- Fold01: mtry=10 
+ Fold01: mtry=12 
- Fold01: mtry=12 
+ Fold01: mtry=14 
- Fold01: mtry=14 
+ Fold01: mtry=16 
- Fold01: mtry=16 
+ Fold01: mtry=18 
- Fold01: mtry=18 
+ Fold01: mtry=20 
- Fold01: mtry=20 
+ Fold01: mtry=22 
- Fold01: mtry=22 
+ Fold01: mtry=24 
- Fold01: mtry=24 
+ Fold01: mtry=26 
- Fold01: mtry=26 
+ Fold01: mtry=28 
- Fold01: mtry=28 
+ Fold01: mtry=30 
- Fold01: mtry=30 
+ Fold01: mtry=32 
- Fold01: mtry=32 
+ Fold01: mtry=34 
- Fold01: mtry=34 
+ Fold01: mtry=36 
- Fold01: mtry=36 
+ Fold01: mtry=38 
- Fold01: mtry=38 
+ Fold01: mtry=40 
- Fold01: mtry=40 
+ Fold01: mtry=42 
- Fold01: mtry=42 
+ Fold01: mtry=44 
- Fold01: mtry=44 
+ Fold01: mtry=46 
- Fold01: mtry=46 
+ Fold01: mtry=48 
- Fold01: mtry=48 
+ Fold01: mtry=50 
- Fold01: mtry=50 
+ Fold01: mtry=52 
- Fold01: mtry=52 
+ Fold01: mtry=54 
- Fold01: mtry=54 
+ Fold01: mtry=56 
- Fold01: mtry=56 
+ Fold01: mtry=58 
- Fold01: mtry=58 
+ Fold01: mtry=60 
- Fold01: mtry=60 
+ Fold01: mtry=62 
- Fold01: mtry=62 
+ Fold01: mtry=64 
- Fold01: mtry=64 
+ Fold01: mtry=66 
- Fold01: mtry=66 
+ Fold01: mtry=68 
- Fold01: mtry=68 
+ Fold01: mtry=70 
- Fold01: mtry=70 
+ Fold01: mtry=72 
- Fold01: mtry=72 
+ Fold01: mtry=74 
- Fold01: mtry=74 
+ Fold01: mtry=76 
- Fold01: mtry=76 
+ Fold02: mtry= 2 
- Fold02: mtry= 2 
+ Fold02: mtry= 4 
- Fold02: mtry= 4 
+ Fold02: mtry= 6 
- Fold02: mtry= 6 
+ Fold02: mtry= 8 
- Fold02: mtry= 8 
+ Fold02: mtry=10 
- Fold02: mtry=10 
+ Fold02: mtry=12 
- Fold02: mtry=12 
+ Fold02: mtry=14 
- Fold02: mtry=14 
+ Fold02: mtry=16 
- Fold02: mtry=16 
+ Fold02: mtry=18 
- Fold02: mtry=18 
+ Fold02: mtry=20 
- Fold02: mtry=20 
+ Fold02: mtry=22 
- Fold02: mtry=22 
+ Fold02: mtry=24 
- Fold02: mtry=24 
+ Fold02: mtry=26 
- Fold02: mtry=26 
+ Fold02: mtry=28 
- Fold02: mtry=28 
+ Fold02: mtry=30 
- Fold02: mtry=30 
+ Fold02: mtry=32 
- Fold02: mtry=32 
+ Fold02: mtry=34 
- Fold02: mtry=34 
+ Fold02: mtry=36 
- Fold02: mtry=36 
+ Fold02: mtry=38 
- Fold02: mtry=38 
+ Fold02: mtry=40 
- Fold02: mtry=40 
+ Fold02: mtry=42 
- Fold02: mtry=42 
+ Fold02: mtry=44 
- Fold02: mtry=44 
+ Fold02: mtry=46 
- Fold02: mtry=46 
+ Fold02: mtry=48 
- Fold02: mtry=48 
+ Fold02: mtry=50 
- Fold02: mtry=50 
+ Fold02: mtry=52 
- Fold02: mtry=52 
+ Fold02: mtry=54 
- Fold02: mtry=54 
+ Fold02: mtry=56 
- Fold02: mtry=56 
+ Fold02: mtry=58 
- Fold02: mtry=58 
+ Fold02: mtry=60 
- Fold02: mtry=60 
+ Fold02: mtry=62 
- Fold02: mtry=62 
+ Fold02: mtry=64 
- Fold02: mtry=64 
+ Fold02: mtry=66 
- Fold02: mtry=66 
+ Fold02: mtry=68 
- Fold02: mtry=68 
+ Fold02: mtry=70 
- Fold02: mtry=70 
+ Fold02: mtry=72 
- Fold02: mtry=72 
+ Fold02: mtry=74 
- Fold02: mtry=74 
+ Fold02: mtry=76 
- Fold02: mtry=76 
+ Fold03: mtry= 2 
- Fold03: mtry= 2 
+ Fold03: mtry= 4 
- Fold03: mtry= 4 
+ Fold03: mtry= 6 
- Fold03: mtry= 6 
+ Fold03: mtry= 8 
- Fold03: mtry= 8 
+ Fold03: mtry=10 
- Fold03: mtry=10 
+ Fold03: mtry=12 
- Fold03: mtry=12 
+ Fold03: mtry=14 
- Fold03: mtry=14 
+ Fold03: mtry=16 
- Fold03: mtry=16 
+ Fold03: mtry=18 
- Fold03: mtry=18 
+ Fold03: mtry=20 
- Fold03: mtry=20 
+ Fold03: mtry=22 
- Fold03: mtry=22 
+ Fold03: mtry=24 
- Fold03: mtry=24 
+ Fold03: mtry=26 
- Fold03: mtry=26 
+ Fold03: mtry=28 
- Fold03: mtry=28 
+ Fold03: mtry=30 
- Fold03: mtry=30 
+ Fold03: mtry=32 
- Fold03: mtry=32 
+ Fold03: mtry=34 
- Fold03: mtry=34 
+ Fold03: mtry=36 
- Fold03: mtry=36 
+ Fold03: mtry=38 
- Fold03: mtry=38 
+ Fold03: mtry=40 
- Fold03: mtry=40 
+ Fold03: mtry=42 
- Fold03: mtry=42 
+ Fold03: mtry=44 
- Fold03: mtry=44 
+ Fold03: mtry=46 
- Fold03: mtry=46 
+ Fold03: mtry=48 
- Fold03: mtry=48 
+ Fold03: mtry=50 
- Fold03: mtry=50 
+ Fold03: mtry=52 
- Fold03: mtry=52 
+ Fold03: mtry=54 
- Fold03: mtry=54 
+ Fold03: mtry=56 
- Fold03: mtry=56 
+ Fold03: mtry=58 
- Fold03: mtry=58 
+ Fold03: mtry=60 
- Fold03: mtry=60 
+ Fold03: mtry=62 
- Fold03: mtry=62 
+ Fold03: mtry=64 
- Fold03: mtry=64 
+ Fold03: mtry=66 
- Fold03: mtry=66 
+ Fold03: mtry=68 
- Fold03: mtry=68 
+ Fold03: mtry=70 
- Fold03: mtry=70 
+ Fold03: mtry=72 
- Fold03: mtry=72 
+ Fold03: mtry=74 
- Fold03: mtry=74 
+ Fold03: mtry=76 
- Fold03: mtry=76 
+ Fold04: mtry= 2 
- Fold04: mtry= 2 
+ Fold04: mtry= 4 
- Fold04: mtry= 4 
+ Fold04: mtry= 6 
- Fold04: mtry= 6 
+ Fold04: mtry= 8 
- Fold04: mtry= 8 
+ Fold04: mtry=10 
- Fold04: mtry=10 
+ Fold04: mtry=12 
- Fold04: mtry=12 
+ Fold04: mtry=14 
- Fold04: mtry=14 
+ Fold04: mtry=16 
- Fold04: mtry=16 
+ Fold04: mtry=18 
- Fold04: mtry=18 
+ Fold04: mtry=20 
- Fold04: mtry=20 
+ Fold04: mtry=22 
- Fold04: mtry=22 
+ Fold04: mtry=24 
- Fold04: mtry=24 
+ Fold04: mtry=26 
- Fold04: mtry=26 
+ Fold04: mtry=28 
- Fold04: mtry=28 
+ Fold04: mtry=30 
- Fold04: mtry=30 
+ Fold04: mtry=32 
- Fold04: mtry=32 
+ Fold04: mtry=34 
- Fold04: mtry=34 
+ Fold04: mtry=36 
- Fold04: mtry=36 
+ Fold04: mtry=38 
- Fold04: mtry=38 
+ Fold04: mtry=40 
- Fold04: mtry=40 
+ Fold04: mtry=42 
- Fold04: mtry=42 
+ Fold04: mtry=44 
- Fold04: mtry=44 
+ Fold04: mtry=46 
- Fold04: mtry=46 
+ Fold04: mtry=48 
- Fold04: mtry=48 
+ Fold04: mtry=50 
- Fold04: mtry=50 
+ Fold04: mtry=52 
- Fold04: mtry=52 
+ Fold04: mtry=54 
- Fold04: mtry=54 
+ Fold04: mtry=56 
- Fold04: mtry=56 
+ Fold04: mtry=58 
- Fold04: mtry=58 
+ Fold04: mtry=60 
- Fold04: mtry=60 
+ Fold04: mtry=62 
- Fold04: mtry=62 
+ Fold04: mtry=64 
- Fold04: mtry=64 
+ Fold04: mtry=66 
- Fold04: mtry=66 
+ Fold04: mtry=68 
- Fold04: mtry=68 
+ Fold04: mtry=70 
- Fold04: mtry=70 
+ Fold04: mtry=72 
- Fold04: mtry=72 
+ Fold04: mtry=74 
- Fold04: mtry=74 
+ Fold04: mtry=76 
- Fold04: mtry=76 
+ Fold05: mtry= 2 
- Fold05: mtry= 2 
+ Fold05: mtry= 4 
- Fold05: mtry= 4 
+ Fold05: mtry= 6 
- Fold05: mtry= 6 
+ Fold05: mtry= 8 
- Fold05: mtry= 8 
+ Fold05: mtry=10 
- Fold05: mtry=10 
+ Fold05: mtry=12 
- Fold05: mtry=12 
+ Fold05: mtry=14 
- Fold05: mtry=14 
+ Fold05: mtry=16 
- Fold05: mtry=16 
+ Fold05: mtry=18 
- Fold05: mtry=18 
+ Fold05: mtry=20 
- Fold05: mtry=20 
+ Fold05: mtry=22 
- Fold05: mtry=22 
+ Fold05: mtry=24 
- Fold05: mtry=24 
+ Fold05: mtry=26 
- Fold05: mtry=26 
+ Fold05: mtry=28 
- Fold05: mtry=28 
+ Fold05: mtry=30 
- Fold05: mtry=30 
+ Fold05: mtry=32 
- Fold05: mtry=32 
+ Fold05: mtry=34 
- Fold05: mtry=34 
+ Fold05: mtry=36 
- Fold05: mtry=36 
+ Fold05: mtry=38 
- Fold05: mtry=38 
+ Fold05: mtry=40 
- Fold05: mtry=40 
+ Fold05: mtry=42 
- Fold05: mtry=42 
+ Fold05: mtry=44 
- Fold05: mtry=44 
+ Fold05: mtry=46 
- Fold05: mtry=46 
+ Fold05: mtry=48 
- Fold05: mtry=48 
+ Fold05: mtry=50 
- Fold05: mtry=50 
+ Fold05: mtry=52 
- Fold05: mtry=52 
+ Fold05: mtry=54 
- Fold05: mtry=54 
+ Fold05: mtry=56 
- Fold05: mtry=56 
+ Fold05: mtry=58 
- Fold05: mtry=58 
+ Fold05: mtry=60 
- Fold05: mtry=60 
+ Fold05: mtry=62 
- Fold05: mtry=62 
+ Fold05: mtry=64 
- Fold05: mtry=64 
+ Fold05: mtry=66 
- Fold05: mtry=66 
+ Fold05: mtry=68 
- Fold05: mtry=68 
+ Fold05: mtry=70 
- Fold05: mtry=70 
+ Fold05: mtry=72 
- Fold05: mtry=72 
+ Fold05: mtry=74 
- Fold05: mtry=74 
+ Fold05: mtry=76 
- Fold05: mtry=76 
+ Fold06: mtry= 2 
- Fold06: mtry= 2 
+ Fold06: mtry= 4 
- Fold06: mtry= 4 
+ Fold06: mtry= 6 
- Fold06: mtry= 6 
+ Fold06: mtry= 8 
- Fold06: mtry= 8 
+ Fold06: mtry=10 
- Fold06: mtry=10 
+ Fold06: mtry=12 
- Fold06: mtry=12 
+ Fold06: mtry=14 
- Fold06: mtry=14 
+ Fold06: mtry=16 
- Fold06: mtry=16 
+ Fold06: mtry=18 
- Fold06: mtry=18 
+ Fold06: mtry=20 
- Fold06: mtry=20 
+ Fold06: mtry=22 
- Fold06: mtry=22 
+ Fold06: mtry=24 
- Fold06: mtry=24 
+ Fold06: mtry=26 
- Fold06: mtry=26 
+ Fold06: mtry=28 
- Fold06: mtry=28 
+ Fold06: mtry=30 
- Fold06: mtry=30 
+ Fold06: mtry=32 
- Fold06: mtry=32 
+ Fold06: mtry=34 
- Fold06: mtry=34 
+ Fold06: mtry=36 
- Fold06: mtry=36 
+ Fold06: mtry=38 
- Fold06: mtry=38 
+ Fold06: mtry=40 
- Fold06: mtry=40 
+ Fold06: mtry=42 
- Fold06: mtry=42 
+ Fold06: mtry=44 
- Fold06: mtry=44 
+ Fold06: mtry=46 
- Fold06: mtry=46 
+ Fold06: mtry=48 
- Fold06: mtry=48 
+ Fold06: mtry=50 
- Fold06: mtry=50 
+ Fold06: mtry=52 
- Fold06: mtry=52 
+ Fold06: mtry=54 
- Fold06: mtry=54 
+ Fold06: mtry=56 
- Fold06: mtry=56 
+ Fold06: mtry=58 
- Fold06: mtry=58 
+ Fold06: mtry=60 
- Fold06: mtry=60 
+ Fold06: mtry=62 
- Fold06: mtry=62 
+ Fold06: mtry=64 
- Fold06: mtry=64 
+ Fold06: mtry=66 
- Fold06: mtry=66 
+ Fold06: mtry=68 
- Fold06: mtry=68 
+ Fold06: mtry=70 
- Fold06: mtry=70 
+ Fold06: mtry=72 
- Fold06: mtry=72 
+ Fold06: mtry=74 
- Fold06: mtry=74 
+ Fold06: mtry=76 
- Fold06: mtry=76 
+ Fold07: mtry= 2 
- Fold07: mtry= 2 
+ Fold07: mtry= 4 
- Fold07: mtry= 4 
+ Fold07: mtry= 6 
- Fold07: mtry= 6 
+ Fold07: mtry= 8 
- Fold07: mtry= 8 
+ Fold07: mtry=10 
- Fold07: mtry=10 
+ Fold07: mtry=12 
- Fold07: mtry=12 
+ Fold07: mtry=14 
- Fold07: mtry=14 
+ Fold07: mtry=16 
- Fold07: mtry=16 
+ Fold07: mtry=18 
- Fold07: mtry=18 
+ Fold07: mtry=20 
- Fold07: mtry=20 
+ Fold07: mtry=22 
- Fold07: mtry=22 
+ Fold07: mtry=24 
- Fold07: mtry=24 
+ Fold07: mtry=26 
- Fold07: mtry=26 
+ Fold07: mtry=28 
- Fold07: mtry=28 
+ Fold07: mtry=30 
- Fold07: mtry=30 
+ Fold07: mtry=32 
- Fold07: mtry=32 
+ Fold07: mtry=34 
- Fold07: mtry=34 
+ Fold07: mtry=36 
- Fold07: mtry=36 
+ Fold07: mtry=38 
- Fold07: mtry=38 
+ Fold07: mtry=40 
- Fold07: mtry=40 
+ Fold07: mtry=42 
- Fold07: mtry=42 
+ Fold07: mtry=44 
- Fold07: mtry=44 
+ Fold07: mtry=46 
- Fold07: mtry=46 
+ Fold07: mtry=48 
- Fold07: mtry=48 
+ Fold07: mtry=50 
- Fold07: mtry=50 
+ Fold07: mtry=52 
- Fold07: mtry=52 
+ Fold07: mtry=54 
- Fold07: mtry=54 
+ Fold07: mtry=56 
- Fold07: mtry=56 
+ Fold07: mtry=58 
- Fold07: mtry=58 
+ Fold07: mtry=60 
- Fold07: mtry=60 
+ Fold07: mtry=62 
- Fold07: mtry=62 
+ Fold07: mtry=64 
- Fold07: mtry=64 
+ Fold07: mtry=66 
- Fold07: mtry=66 
+ Fold07: mtry=68 
- Fold07: mtry=68 
+ Fold07: mtry=70 
- Fold07: mtry=70 
+ Fold07: mtry=72 
- Fold07: mtry=72 
+ Fold07: mtry=74 
- Fold07: mtry=74 
+ Fold07: mtry=76 
- Fold07: mtry=76 
+ Fold08: mtry= 2 
- Fold08: mtry= 2 
+ Fold08: mtry= 4 
- Fold08: mtry= 4 
+ Fold08: mtry= 6 
- Fold08: mtry= 6 
+ Fold08: mtry= 8 
- Fold08: mtry= 8 
+ Fold08: mtry=10 
- Fold08: mtry=10 
+ Fold08: mtry=12 
- Fold08: mtry=12 
+ Fold08: mtry=14 
- Fold08: mtry=14 
+ Fold08: mtry=16 
- Fold08: mtry=16 
+ Fold08: mtry=18 
- Fold08: mtry=18 
+ Fold08: mtry=20 
- Fold08: mtry=20 
+ Fold08: mtry=22 
- Fold08: mtry=22 
+ Fold08: mtry=24 
- Fold08: mtry=24 
+ Fold08: mtry=26 
- Fold08: mtry=26 
+ Fold08: mtry=28 
- Fold08: mtry=28 
+ Fold08: mtry=30 
- Fold08: mtry=30 
+ Fold08: mtry=32 
- Fold08: mtry=32 
+ Fold08: mtry=34 
- Fold08: mtry=34 
+ Fold08: mtry=36 
- Fold08: mtry=36 
+ Fold08: mtry=38 
- Fold08: mtry=38 
+ Fold08: mtry=40 
- Fold08: mtry=40 
+ Fold08: mtry=42 
- Fold08: mtry=42 
+ Fold08: mtry=44 
- Fold08: mtry=44 
+ Fold08: mtry=46 
- Fold08: mtry=46 
+ Fold08: mtry=48 
- Fold08: mtry=48 
+ Fold08: mtry=50 
- Fold08: mtry=50 
+ Fold08: mtry=52 
- Fold08: mtry=52 
+ Fold08: mtry=54 
- Fold08: mtry=54 
+ Fold08: mtry=56 
- Fold08: mtry=56 
+ Fold08: mtry=58 
- Fold08: mtry=58 
+ Fold08: mtry=60 
- Fold08: mtry=60 
+ Fold08: mtry=62 
- Fold08: mtry=62 
+ Fold08: mtry=64 
- Fold08: mtry=64 
+ Fold08: mtry=66 
- Fold08: mtry=66 
+ Fold08: mtry=68 
- Fold08: mtry=68 
+ Fold08: mtry=70 
- Fold08: mtry=70 
+ Fold08: mtry=72 
- Fold08: mtry=72 
+ Fold08: mtry=74 
- Fold08: mtry=74 
+ Fold08: mtry=76 
- Fold08: mtry=76 
+ Fold09: mtry= 2 
- Fold09: mtry= 2 
+ Fold09: mtry= 4 
- Fold09: mtry= 4 
+ Fold09: mtry= 6 
- Fold09: mtry= 6 
+ Fold09: mtry= 8 
- Fold09: mtry= 8 
+ Fold09: mtry=10 
- Fold09: mtry=10 
+ Fold09: mtry=12 
- Fold09: mtry=12 
+ Fold09: mtry=14 
- Fold09: mtry=14 
+ Fold09: mtry=16 
- Fold09: mtry=16 
+ Fold09: mtry=18 
- Fold09: mtry=18 
+ Fold09: mtry=20 
- Fold09: mtry=20 
+ Fold09: mtry=22 
- Fold09: mtry=22 
+ Fold09: mtry=24 
- Fold09: mtry=24 
+ Fold09: mtry=26 
- Fold09: mtry=26 
+ Fold09: mtry=28 
- Fold09: mtry=28 
+ Fold09: mtry=30 
- Fold09: mtry=30 
+ Fold09: mtry=32 
- Fold09: mtry=32 
+ Fold09: mtry=34 
- Fold09: mtry=34 
+ Fold09: mtry=36 
- Fold09: mtry=36 
+ Fold09: mtry=38 
- Fold09: mtry=38 
+ Fold09: mtry=40 
- Fold09: mtry=40 
+ Fold09: mtry=42 
- Fold09: mtry=42 
+ Fold09: mtry=44 
- Fold09: mtry=44 
+ Fold09: mtry=46 
- Fold09: mtry=46 
+ Fold09: mtry=48 
- Fold09: mtry=48 
+ Fold09: mtry=50 
- Fold09: mtry=50 
+ Fold09: mtry=52 
- Fold09: mtry=52 
+ Fold09: mtry=54 
- Fold09: mtry=54 
+ Fold09: mtry=56 
- Fold09: mtry=56 
+ Fold09: mtry=58 
- Fold09: mtry=58 
+ Fold09: mtry=60 
- Fold09: mtry=60 
+ Fold09: mtry=62 
- Fold09: mtry=62 
+ Fold09: mtry=64 
- Fold09: mtry=64 
+ Fold09: mtry=66 
- Fold09: mtry=66 
+ Fold09: mtry=68 
- Fold09: mtry=68 
+ Fold09: mtry=70 
- Fold09: mtry=70 
+ Fold09: mtry=72 
- Fold09: mtry=72 
+ Fold09: mtry=74 
- Fold09: mtry=74 
+ Fold09: mtry=76 
- Fold09: mtry=76 
+ Fold10: mtry= 2 
- Fold10: mtry= 2 
+ Fold10: mtry= 4 
- Fold10: mtry= 4 
+ Fold10: mtry= 6 
- Fold10: mtry= 6 
+ Fold10: mtry= 8 
- Fold10: mtry= 8 
+ Fold10: mtry=10 
- Fold10: mtry=10 
+ Fold10: mtry=12 
- Fold10: mtry=12 
+ Fold10: mtry=14 
- Fold10: mtry=14 
+ Fold10: mtry=16 
- Fold10: mtry=16 
+ Fold10: mtry=18 
- Fold10: mtry=18 
+ Fold10: mtry=20 
- Fold10: mtry=20 
+ Fold10: mtry=22 
- Fold10: mtry=22 
+ Fold10: mtry=24 
- Fold10: mtry=24 
+ Fold10: mtry=26 
- Fold10: mtry=26 
+ Fold10: mtry=28 
- Fold10: mtry=28 
+ Fold10: mtry=30 
- Fold10: mtry=30 
+ Fold10: mtry=32 
- Fold10: mtry=32 
+ Fold10: mtry=34 
- Fold10: mtry=34 
+ Fold10: mtry=36 
- Fold10: mtry=36 
+ Fold10: mtry=38 
- Fold10: mtry=38 
+ Fold10: mtry=40 
- Fold10: mtry=40 
+ Fold10: mtry=42 
- Fold10: mtry=42 
+ Fold10: mtry=44 
- Fold10: mtry=44 
+ Fold10: mtry=46 
- Fold10: mtry=46 
+ Fold10: mtry=48 
- Fold10: mtry=48 
+ Fold10: mtry=50 
- Fold10: mtry=50 
+ Fold10: mtry=52 
- Fold10: mtry=52 
+ Fold10: mtry=54 
- Fold10: mtry=54 
+ Fold10: mtry=56 
- Fold10: mtry=56 
+ Fold10: mtry=58 
- Fold10: mtry=58 
+ Fold10: mtry=60 
- Fold10: mtry=60 
+ Fold10: mtry=62 
- Fold10: mtry=62 
+ Fold10: mtry=64 
- Fold10: mtry=64 
+ Fold10: mtry=66 
- Fold10: mtry=66 
+ Fold10: mtry=68 
- Fold10: mtry=68 
+ Fold10: mtry=70 
- Fold10: mtry=70 
+ Fold10: mtry=72 
- Fold10: mtry=72 
+ Fold10: mtry=74 
- Fold10: mtry=74 
+ Fold10: mtry=76 
- Fold10: mtry=76 
+ Fold11: mtry= 2 
- Fold11: mtry= 2 
+ Fold11: mtry= 4 
- Fold11: mtry= 4 
+ Fold11: mtry= 6 
- Fold11: mtry= 6 
+ Fold11: mtry= 8 
- Fold11: mtry= 8 
+ Fold11: mtry=10 
- Fold11: mtry=10 
+ Fold11: mtry=12 
- Fold11: mtry=12 
+ Fold11: mtry=14 
- Fold11: mtry=14 
+ Fold11: mtry=16 
- Fold11: mtry=16 
+ Fold11: mtry=18 
- Fold11: mtry=18 
+ Fold11: mtry=20 
- Fold11: mtry=20 
+ Fold11: mtry=22 
- Fold11: mtry=22 
+ Fold11: mtry=24 
- Fold11: mtry=24 
+ Fold11: mtry=26 
- Fold11: mtry=26 
+ Fold11: mtry=28 
- Fold11: mtry=28 
+ Fold11: mtry=30 
- Fold11: mtry=30 
+ Fold11: mtry=32 
- Fold11: mtry=32 
+ Fold11: mtry=34 
- Fold11: mtry=34 
+ Fold11: mtry=36 
- Fold11: mtry=36 
+ Fold11: mtry=38 
- Fold11: mtry=38 
+ Fold11: mtry=40 
- Fold11: mtry=40 
+ Fold11: mtry=42 
- Fold11: mtry=42 
+ Fold11: mtry=44 
- Fold11: mtry=44 
+ Fold11: mtry=46 
- Fold11: mtry=46 
+ Fold11: mtry=48 
- Fold11: mtry=48 
+ Fold11: mtry=50 
- Fold11: mtry=50 
+ Fold11: mtry=52 
- Fold11: mtry=52 
+ Fold11: mtry=54 
- Fold11: mtry=54 
+ Fold11: mtry=56 
- Fold11: mtry=56 
+ Fold11: mtry=58 
- Fold11: mtry=58 
+ Fold11: mtry=60 
- Fold11: mtry=60 
+ Fold11: mtry=62 
- Fold11: mtry=62 
+ Fold11: mtry=64 
- Fold11: mtry=64 
+ Fold11: mtry=66 
- Fold11: mtry=66 
+ Fold11: mtry=68 
- Fold11: mtry=68 
+ Fold11: mtry=70 
- Fold11: mtry=70 
+ Fold11: mtry=72 
- Fold11: mtry=72 
+ Fold11: mtry=74 
- Fold11: mtry=74 
+ Fold11: mtry=76 
- Fold11: mtry=76 
+ Fold12: mtry= 2 
- Fold12: mtry= 2 
+ Fold12: mtry= 4 
- Fold12: mtry= 4 
+ Fold12: mtry= 6 
- Fold12: mtry= 6 
+ Fold12: mtry= 8 
- Fold12: mtry= 8 
+ Fold12: mtry=10 
- Fold12: mtry=10 
+ Fold12: mtry=12 
- Fold12: mtry=12 
+ Fold12: mtry=14 
- Fold12: mtry=14 
+ Fold12: mtry=16 
- Fold12: mtry=16 
+ Fold12: mtry=18 
- Fold12: mtry=18 
+ Fold12: mtry=20 
- Fold12: mtry=20 
+ Fold12: mtry=22 
- Fold12: mtry=22 
+ Fold12: mtry=24 
- Fold12: mtry=24 
+ Fold12: mtry=26 
- Fold12: mtry=26 
+ Fold12: mtry=28 
- Fold12: mtry=28 
+ Fold12: mtry=30 
- Fold12: mtry=30 
+ Fold12: mtry=32 
- Fold12: mtry=32 
+ Fold12: mtry=34 
- Fold12: mtry=34 
+ Fold12: mtry=36 
- Fold12: mtry=36 
+ Fold12: mtry=38 
- Fold12: mtry=38 
+ Fold12: mtry=40 
- Fold12: mtry=40 
+ Fold12: mtry=42 
- Fold12: mtry=42 
+ Fold12: mtry=44 
- Fold12: mtry=44 
+ Fold12: mtry=46 
- Fold12: mtry=46 
+ Fold12: mtry=48 
- Fold12: mtry=48 
+ Fold12: mtry=50 
- Fold12: mtry=50 
+ Fold12: mtry=52 
- Fold12: mtry=52 
+ Fold12: mtry=54 
- Fold12: mtry=54 
+ Fold12: mtry=56 
- Fold12: mtry=56 
+ Fold12: mtry=58 
- Fold12: mtry=58 
+ Fold12: mtry=60 
- Fold12: mtry=60 
+ Fold12: mtry=62 
- Fold12: mtry=62 
+ Fold12: mtry=64 
- Fold12: mtry=64 
+ Fold12: mtry=66 
- Fold12: mtry=66 
+ Fold12: mtry=68 
- Fold12: mtry=68 
+ Fold12: mtry=70 
- Fold12: mtry=70 
+ Fold12: mtry=72 
- Fold12: mtry=72 
+ Fold12: mtry=74 
- Fold12: mtry=74 
+ Fold12: mtry=76 
- Fold12: mtry=76 
+ Fold13: mtry= 2 
- Fold13: mtry= 2 
+ Fold13: mtry= 4 
- Fold13: mtry= 4 
+ Fold13: mtry= 6 
- Fold13: mtry= 6 
+ Fold13: mtry= 8 
- Fold13: mtry= 8 
+ Fold13: mtry=10 
- Fold13: mtry=10 
+ Fold13: mtry=12 
- Fold13: mtry=12 
+ Fold13: mtry=14 
- Fold13: mtry=14 
+ Fold13: mtry=16 
- Fold13: mtry=16 
+ Fold13: mtry=18 
- Fold13: mtry=18 
+ Fold13: mtry=20 
- Fold13: mtry=20 
+ Fold13: mtry=22 
- Fold13: mtry=22 
+ Fold13: mtry=24 
- Fold13: mtry=24 
+ Fold13: mtry=26 
- Fold13: mtry=26 
+ Fold13: mtry=28 
- Fold13: mtry=28 
+ Fold13: mtry=30 
- Fold13: mtry=30 
+ Fold13: mtry=32 
- Fold13: mtry=32 
+ Fold13: mtry=34 
- Fold13: mtry=34 
+ Fold13: mtry=36 
- Fold13: mtry=36 
+ Fold13: mtry=38 
- Fold13: mtry=38 
+ Fold13: mtry=40 
- Fold13: mtry=40 
+ Fold13: mtry=42 
- Fold13: mtry=42 
+ Fold13: mtry=44 
- Fold13: mtry=44 
+ Fold13: mtry=46 
- Fold13: mtry=46 
+ Fold13: mtry=48 
- Fold13: mtry=48 
+ Fold13: mtry=50 
- Fold13: mtry=50 
+ Fold13: mtry=52 
- Fold13: mtry=52 
+ Fold13: mtry=54 
- Fold13: mtry=54 
+ Fold13: mtry=56 
- Fold13: mtry=56 
+ Fold13: mtry=58 
- Fold13: mtry=58 
+ Fold13: mtry=60 
- Fold13: mtry=60 
+ Fold13: mtry=62 
- Fold13: mtry=62 
+ Fold13: mtry=64 
- Fold13: mtry=64 
+ Fold13: mtry=66 
- Fold13: mtry=66 
+ Fold13: mtry=68 
- Fold13: mtry=68 
+ Fold13: mtry=70 
- Fold13: mtry=70 
+ Fold13: mtry=72 
- Fold13: mtry=72 
+ Fold13: mtry=74 
- Fold13: mtry=74 
+ Fold13: mtry=76 
- Fold13: mtry=76 
+ Fold14: mtry= 2 
- Fold14: mtry= 2 
+ Fold14: mtry= 4 
- Fold14: mtry= 4 
+ Fold14: mtry= 6 
- Fold14: mtry= 6 
+ Fold14: mtry= 8 
- Fold14: mtry= 8 
+ Fold14: mtry=10 
- Fold14: mtry=10 
+ Fold14: mtry=12 
- Fold14: mtry=12 
+ Fold14: mtry=14 
- Fold14: mtry=14 
+ Fold14: mtry=16 
- Fold14: mtry=16 
+ Fold14: mtry=18 
- Fold14: mtry=18 
+ Fold14: mtry=20 
- Fold14: mtry=20 
+ Fold14: mtry=22 
- Fold14: mtry=22 
+ Fold14: mtry=24 
- Fold14: mtry=24 
+ Fold14: mtry=26 
- Fold14: mtry=26 
+ Fold14: mtry=28 
- Fold14: mtry=28 
+ Fold14: mtry=30 
- Fold14: mtry=30 
+ Fold14: mtry=32 
- Fold14: mtry=32 
+ Fold14: mtry=34 
- Fold14: mtry=34 
+ Fold14: mtry=36 
- Fold14: mtry=36 
+ Fold14: mtry=38 
- Fold14: mtry=38 
+ Fold14: mtry=40 
- Fold14: mtry=40 
+ Fold14: mtry=42 
- Fold14: mtry=42 
+ Fold14: mtry=44 
- Fold14: mtry=44 
+ Fold14: mtry=46 
- Fold14: mtry=46 
+ Fold14: mtry=48 
- Fold14: mtry=48 
+ Fold14: mtry=50 
- Fold14: mtry=50 
+ Fold14: mtry=52 
- Fold14: mtry=52 
+ Fold14: mtry=54 
- Fold14: mtry=54 
+ Fold14: mtry=56 
- Fold14: mtry=56 
+ Fold14: mtry=58 
- Fold14: mtry=58 
+ Fold14: mtry=60 
- Fold14: mtry=60 
+ Fold14: mtry=62 
- Fold14: mtry=62 
+ Fold14: mtry=64 
- Fold14: mtry=64 
+ Fold14: mtry=66 
- Fold14: mtry=66 
+ Fold14: mtry=68 
- Fold14: mtry=68 
+ Fold14: mtry=70 
- Fold14: mtry=70 
+ Fold14: mtry=72 
- Fold14: mtry=72 
+ Fold14: mtry=74 
- Fold14: mtry=74 
+ Fold14: mtry=76 
- Fold14: mtry=76 
+ Fold15: mtry= 2 
- Fold15: mtry= 2 
+ Fold15: mtry= 4 
- Fold15: mtry= 4 
+ Fold15: mtry= 6 
- Fold15: mtry= 6 
+ Fold15: mtry= 8 
- Fold15: mtry= 8 
+ Fold15: mtry=10 
- Fold15: mtry=10 
+ Fold15: mtry=12 
- Fold15: mtry=12 
+ Fold15: mtry=14 
- Fold15: mtry=14 
+ Fold15: mtry=16 
- Fold15: mtry=16 
+ Fold15: mtry=18 
- Fold15: mtry=18 
+ Fold15: mtry=20 
- Fold15: mtry=20 
+ Fold15: mtry=22 
- Fold15: mtry=22 
+ Fold15: mtry=24 
- Fold15: mtry=24 
+ Fold15: mtry=26 
- Fold15: mtry=26 
+ Fold15: mtry=28 
- Fold15: mtry=28 
+ Fold15: mtry=30 
- Fold15: mtry=30 
+ Fold15: mtry=32 
- Fold15: mtry=32 
+ Fold15: mtry=34 
- Fold15: mtry=34 
+ Fold15: mtry=36 
- Fold15: mtry=36 
+ Fold15: mtry=38 
- Fold15: mtry=38 
+ Fold15: mtry=40 
- Fold15: mtry=40 
+ Fold15: mtry=42 
- Fold15: mtry=42 
+ Fold15: mtry=44 
- Fold15: mtry=44 
+ Fold15: mtry=46 
- Fold15: mtry=46 
+ Fold15: mtry=48 
- Fold15: mtry=48 
+ Fold15: mtry=50 
- Fold15: mtry=50 
+ Fold15: mtry=52 
- Fold15: mtry=52 
+ Fold15: mtry=54 
- Fold15: mtry=54 
+ Fold15: mtry=56 
- Fold15: mtry=56 
+ Fold15: mtry=58 
- Fold15: mtry=58 
+ Fold15: mtry=60 
- Fold15: mtry=60 
+ Fold15: mtry=62 
- Fold15: mtry=62 
+ Fold15: mtry=64 
- Fold15: mtry=64 
+ Fold15: mtry=66 
- Fold15: mtry=66 
+ Fold15: mtry=68 
- Fold15: mtry=68 
+ Fold15: mtry=70 
- Fold15: mtry=70 
+ Fold15: mtry=72 
- Fold15: mtry=72 
+ Fold15: mtry=74 
- Fold15: mtry=74 
+ Fold15: mtry=76 
- Fold15: mtry=76 
+ Fold16: mtry= 2 
- Fold16: mtry= 2 
+ Fold16: mtry= 4 
- Fold16: mtry= 4 
+ Fold16: mtry= 6 
- Fold16: mtry= 6 
+ Fold16: mtry= 8 
- Fold16: mtry= 8 
+ Fold16: mtry=10 
- Fold16: mtry=10 
+ Fold16: mtry=12 
- Fold16: mtry=12 
+ Fold16: mtry=14 
- Fold16: mtry=14 
+ Fold16: mtry=16 
- Fold16: mtry=16 
+ Fold16: mtry=18 
- Fold16: mtry=18 
+ Fold16: mtry=20 
- Fold16: mtry=20 
+ Fold16: mtry=22 
- Fold16: mtry=22 
+ Fold16: mtry=24 
- Fold16: mtry=24 
+ Fold16: mtry=26 
- Fold16: mtry=26 
+ Fold16: mtry=28 
- Fold16: mtry=28 
+ Fold16: mtry=30 
- Fold16: mtry=30 
+ Fold16: mtry=32 
- Fold16: mtry=32 
+ Fold16: mtry=34 
- Fold16: mtry=34 
+ Fold16: mtry=36 
- Fold16: mtry=36 
+ Fold16: mtry=38 
- Fold16: mtry=38 
+ Fold16: mtry=40 
- Fold16: mtry=40 
+ Fold16: mtry=42 
- Fold16: mtry=42 
+ Fold16: mtry=44 
- Fold16: mtry=44 
+ Fold16: mtry=46 
- Fold16: mtry=46 
+ Fold16: mtry=48 
- Fold16: mtry=48 
+ Fold16: mtry=50 
- Fold16: mtry=50 
+ Fold16: mtry=52 
- Fold16: mtry=52 
+ Fold16: mtry=54 
- Fold16: mtry=54 
+ Fold16: mtry=56 
- Fold16: mtry=56 
+ Fold16: mtry=58 
- Fold16: mtry=58 
+ Fold16: mtry=60 
- Fold16: mtry=60 
+ Fold16: mtry=62 
- Fold16: mtry=62 
+ Fold16: mtry=64 
- Fold16: mtry=64 
+ Fold16: mtry=66 
- Fold16: mtry=66 
+ Fold16: mtry=68 
- Fold16: mtry=68 
+ Fold16: mtry=70 
- Fold16: mtry=70 
+ Fold16: mtry=72 
- Fold16: mtry=72 
+ Fold16: mtry=74 
- Fold16: mtry=74 
+ Fold16: mtry=76 
- Fold16: mtry=76 
+ Fold17: mtry= 2 
- Fold17: mtry= 2 
+ Fold17: mtry= 4 
- Fold17: mtry= 4 
+ Fold17: mtry= 6 
- Fold17: mtry= 6 
+ Fold17: mtry= 8 
- Fold17: mtry= 8 
+ Fold17: mtry=10 
- Fold17: mtry=10 
+ Fold17: mtry=12 
- Fold17: mtry=12 
+ Fold17: mtry=14 
- Fold17: mtry=14 
+ Fold17: mtry=16 
- Fold17: mtry=16 
+ Fold17: mtry=18 
- Fold17: mtry=18 
+ Fold17: mtry=20 
- Fold17: mtry=20 
+ Fold17: mtry=22 
- Fold17: mtry=22 
+ Fold17: mtry=24 
- Fold17: mtry=24 
+ Fold17: mtry=26 
- Fold17: mtry=26 
+ Fold17: mtry=28 
- Fold17: mtry=28 
+ Fold17: mtry=30 
- Fold17: mtry=30 
+ Fold17: mtry=32 
- Fold17: mtry=32 
+ Fold17: mtry=34 
- Fold17: mtry=34 
+ Fold17: mtry=36 
- Fold17: mtry=36 
+ Fold17: mtry=38 
- Fold17: mtry=38 
+ Fold17: mtry=40 
- Fold17: mtry=40 
+ Fold17: mtry=42 
- Fold17: mtry=42 
+ Fold17: mtry=44 
- Fold17: mtry=44 
+ Fold17: mtry=46 
- Fold17: mtry=46 
+ Fold17: mtry=48 
- Fold17: mtry=48 
+ Fold17: mtry=50 
- Fold17: mtry=50 
+ Fold17: mtry=52 
- Fold17: mtry=52 
+ Fold17: mtry=54 
- Fold17: mtry=54 
+ Fold17: mtry=56 
- Fold17: mtry=56 
+ Fold17: mtry=58 
- Fold17: mtry=58 
+ Fold17: mtry=60 
- Fold17: mtry=60 
+ Fold17: mtry=62 
- Fold17: mtry=62 
+ Fold17: mtry=64 
- Fold17: mtry=64 
+ Fold17: mtry=66 
- Fold17: mtry=66 
+ Fold17: mtry=68 
- Fold17: mtry=68 
+ Fold17: mtry=70 
- Fold17: mtry=70 
+ Fold17: mtry=72 
- Fold17: mtry=72 
+ Fold17: mtry=74 
- Fold17: mtry=74 
+ Fold17: mtry=76 
- Fold17: mtry=76 
+ Fold18: mtry= 2 
- Fold18: mtry= 2 
+ Fold18: mtry= 4 
- Fold18: mtry= 4 
+ Fold18: mtry= 6 
- Fold18: mtry= 6 
+ Fold18: mtry= 8 
- Fold18: mtry= 8 
+ Fold18: mtry=10 
- Fold18: mtry=10 
+ Fold18: mtry=12 
- Fold18: mtry=12 
+ Fold18: mtry=14 
- Fold18: mtry=14 
+ Fold18: mtry=16 
- Fold18: mtry=16 
+ Fold18: mtry=18 
- Fold18: mtry=18 
+ Fold18: mtry=20 
- Fold18: mtry=20 
+ Fold18: mtry=22 
- Fold18: mtry=22 
+ Fold18: mtry=24 
- Fold18: mtry=24 
+ Fold18: mtry=26 
- Fold18: mtry=26 
+ Fold18: mtry=28 
- Fold18: mtry=28 
+ Fold18: mtry=30 
- Fold18: mtry=30 
+ Fold18: mtry=32 
- Fold18: mtry=32 
+ Fold18: mtry=34 
- Fold18: mtry=34 
+ Fold18: mtry=36 
- Fold18: mtry=36 
+ Fold18: mtry=38 
- Fold18: mtry=38 
+ Fold18: mtry=40 
- Fold18: mtry=40 
+ Fold18: mtry=42 
- Fold18: mtry=42 
+ Fold18: mtry=44 
- Fold18: mtry=44 
+ Fold18: mtry=46 
- Fold18: mtry=46 
+ Fold18: mtry=48 
- Fold18: mtry=48 
+ Fold18: mtry=50 
- Fold18: mtry=50 
+ Fold18: mtry=52 
- Fold18: mtry=52 
+ Fold18: mtry=54 
- Fold18: mtry=54 
+ Fold18: mtry=56 
- Fold18: mtry=56 
+ Fold18: mtry=58 
- Fold18: mtry=58 
+ Fold18: mtry=60 
- Fold18: mtry=60 
+ Fold18: mtry=62 
- Fold18: mtry=62 
+ Fold18: mtry=64 
- Fold18: mtry=64 
+ Fold18: mtry=66 
- Fold18: mtry=66 
+ Fold18: mtry=68 
- Fold18: mtry=68 
+ Fold18: mtry=70 
- Fold18: mtry=70 
+ Fold18: mtry=72 
- Fold18: mtry=72 
+ Fold18: mtry=74 
- Fold18: mtry=74 
+ Fold18: mtry=76 
- Fold18: mtry=76 
+ Fold19: mtry= 2 
- Fold19: mtry= 2 
+ Fold19: mtry= 4 
- Fold19: mtry= 4 
+ Fold19: mtry= 6 
- Fold19: mtry= 6 
+ Fold19: mtry= 8 
- Fold19: mtry= 8 
+ Fold19: mtry=10 
- Fold19: mtry=10 
+ Fold19: mtry=12 
- Fold19: mtry=12 
+ Fold19: mtry=14 
- Fold19: mtry=14 
+ Fold19: mtry=16 
- Fold19: mtry=16 
+ Fold19: mtry=18 
- Fold19: mtry=18 
+ Fold19: mtry=20 
- Fold19: mtry=20 
+ Fold19: mtry=22 
- Fold19: mtry=22 
+ Fold19: mtry=24 
- Fold19: mtry=24 
+ Fold19: mtry=26 
- Fold19: mtry=26 
+ Fold19: mtry=28 
- Fold19: mtry=28 
+ Fold19: mtry=30 
- Fold19: mtry=30 
+ Fold19: mtry=32 
- Fold19: mtry=32 
+ Fold19: mtry=34 
- Fold19: mtry=34 
+ Fold19: mtry=36 
- Fold19: mtry=36 
+ Fold19: mtry=38 
- Fold19: mtry=38 
+ Fold19: mtry=40 
- Fold19: mtry=40 
+ Fold19: mtry=42 
- Fold19: mtry=42 
+ Fold19: mtry=44 
- Fold19: mtry=44 
+ Fold19: mtry=46 
- Fold19: mtry=46 
+ Fold19: mtry=48 
- Fold19: mtry=48 
+ Fold19: mtry=50 
- Fold19: mtry=50 
+ Fold19: mtry=52 
- Fold19: mtry=52 
+ Fold19: mtry=54 
- Fold19: mtry=54 
+ Fold19: mtry=56 
- Fold19: mtry=56 
+ Fold19: mtry=58 
- Fold19: mtry=58 
+ Fold19: mtry=60 
- Fold19: mtry=60 
+ Fold19: mtry=62 
- Fold19: mtry=62 
+ Fold19: mtry=64 
- Fold19: mtry=64 
+ Fold19: mtry=66 
- Fold19: mtry=66 
+ Fold19: mtry=68 
- Fold19: mtry=68 
+ Fold19: mtry=70 
- Fold19: mtry=70 
+ Fold19: mtry=72 
- Fold19: mtry=72 
+ Fold19: mtry=74 
- Fold19: mtry=74 
+ Fold19: mtry=76 
- Fold19: mtry=76 
+ Fold20: mtry= 2 
- Fold20: mtry= 2 
+ Fold20: mtry= 4 
- Fold20: mtry= 4 
+ Fold20: mtry= 6 
- Fold20: mtry= 6 
+ Fold20: mtry= 8 
- Fold20: mtry= 8 
+ Fold20: mtry=10 
- Fold20: mtry=10 
+ Fold20: mtry=12 
- Fold20: mtry=12 
+ Fold20: mtry=14 
- Fold20: mtry=14 
+ Fold20: mtry=16 
- Fold20: mtry=16 
+ Fold20: mtry=18 
- Fold20: mtry=18 
+ Fold20: mtry=20 
- Fold20: mtry=20 
+ Fold20: mtry=22 
- Fold20: mtry=22 
+ Fold20: mtry=24 
- Fold20: mtry=24 
+ Fold20: mtry=26 
- Fold20: mtry=26 
+ Fold20: mtry=28 
- Fold20: mtry=28 
+ Fold20: mtry=30 
- Fold20: mtry=30 
+ Fold20: mtry=32 
- Fold20: mtry=32 
+ Fold20: mtry=34 
- Fold20: mtry=34 
+ Fold20: mtry=36 
- Fold20: mtry=36 
+ Fold20: mtry=38 
- Fold20: mtry=38 
+ Fold20: mtry=40 
- Fold20: mtry=40 
+ Fold20: mtry=42 
- Fold20: mtry=42 
+ Fold20: mtry=44 
- Fold20: mtry=44 
+ Fold20: mtry=46 
- Fold20: mtry=46 
+ Fold20: mtry=48 
- Fold20: mtry=48 
+ Fold20: mtry=50 
- Fold20: mtry=50 
+ Fold20: mtry=52 
- Fold20: mtry=52 
+ Fold20: mtry=54 
- Fold20: mtry=54 
+ Fold20: mtry=56 
- Fold20: mtry=56 
+ Fold20: mtry=58 
- Fold20: mtry=58 
+ Fold20: mtry=60 
- Fold20: mtry=60 
+ Fold20: mtry=62 
- Fold20: mtry=62 
+ Fold20: mtry=64 
- Fold20: mtry=64 
+ Fold20: mtry=66 
- Fold20: mtry=66 
+ Fold20: mtry=68 
- Fold20: mtry=68 
+ Fold20: mtry=70 
- Fold20: mtry=70 
+ Fold20: mtry=72 
- Fold20: mtry=72 
+ Fold20: mtry=74 
- Fold20: mtry=74 
+ Fold20: mtry=76 
- Fold20: mtry=76 
+ Fold21: mtry= 2 
- Fold21: mtry= 2 
+ Fold21: mtry= 4 
- Fold21: mtry= 4 
+ Fold21: mtry= 6 
- Fold21: mtry= 6 
+ Fold21: mtry= 8 
- Fold21: mtry= 8 
+ Fold21: mtry=10 
- Fold21: mtry=10 
+ Fold21: mtry=12 
- Fold21: mtry=12 
+ Fold21: mtry=14 
- Fold21: mtry=14 
+ Fold21: mtry=16 
- Fold21: mtry=16 
+ Fold21: mtry=18 
- Fold21: mtry=18 
+ Fold21: mtry=20 
- Fold21: mtry=20 
+ Fold21: mtry=22 
- Fold21: mtry=22 
+ Fold21: mtry=24 
- Fold21: mtry=24 
+ Fold21: mtry=26 
- Fold21: mtry=26 
+ Fold21: mtry=28 
- Fold21: mtry=28 
+ Fold21: mtry=30 
- Fold21: mtry=30 
+ Fold21: mtry=32 
- Fold21: mtry=32 
+ Fold21: mtry=34 
- Fold21: mtry=34 
+ Fold21: mtry=36 
- Fold21: mtry=36 
+ Fold21: mtry=38 
- Fold21: mtry=38 
+ Fold21: mtry=40 
- Fold21: mtry=40 
+ Fold21: mtry=42 
- Fold21: mtry=42 
+ Fold21: mtry=44 
- Fold21: mtry=44 
+ Fold21: mtry=46 
- Fold21: mtry=46 
+ Fold21: mtry=48 
- Fold21: mtry=48 
+ Fold21: mtry=50 
- Fold21: mtry=50 
+ Fold21: mtry=52 
- Fold21: mtry=52 
+ Fold21: mtry=54 
- Fold21: mtry=54 
+ Fold21: mtry=56 
- Fold21: mtry=56 
+ Fold21: mtry=58 
- Fold21: mtry=58 
+ Fold21: mtry=60 
- Fold21: mtry=60 
+ Fold21: mtry=62 
- Fold21: mtry=62 
+ Fold21: mtry=64 
- Fold21: mtry=64 
+ Fold21: mtry=66 
- Fold21: mtry=66 
+ Fold21: mtry=68 
- Fold21: mtry=68 
+ Fold21: mtry=70 
- Fold21: mtry=70 
+ Fold21: mtry=72 
- Fold21: mtry=72 
+ Fold21: mtry=74 
- Fold21: mtry=74 
+ Fold21: mtry=76 
- Fold21: mtry=76 
+ Fold22: mtry= 2 
- Fold22: mtry= 2 
+ Fold22: mtry= 4 
- Fold22: mtry= 4 
+ Fold22: mtry= 6 
- Fold22: mtry= 6 
+ Fold22: mtry= 8 
- Fold22: mtry= 8 
+ Fold22: mtry=10 
- Fold22: mtry=10 
+ Fold22: mtry=12 
- Fold22: mtry=12 
+ Fold22: mtry=14 
- Fold22: mtry=14 
+ Fold22: mtry=16 
- Fold22: mtry=16 
+ Fold22: mtry=18 
- Fold22: mtry=18 
+ Fold22: mtry=20 
- Fold22: mtry=20 
+ Fold22: mtry=22 
- Fold22: mtry=22 
+ Fold22: mtry=24 
- Fold22: mtry=24 
+ Fold22: mtry=26 
- Fold22: mtry=26 
+ Fold22: mtry=28 
- Fold22: mtry=28 
+ Fold22: mtry=30 
- Fold22: mtry=30 
+ Fold22: mtry=32 
- Fold22: mtry=32 
+ Fold22: mtry=34 
- Fold22: mtry=34 
+ Fold22: mtry=36 
- Fold22: mtry=36 
+ Fold22: mtry=38 
- Fold22: mtry=38 
+ Fold22: mtry=40 
- Fold22: mtry=40 
+ Fold22: mtry=42 
- Fold22: mtry=42 
+ Fold22: mtry=44 
- Fold22: mtry=44 
+ Fold22: mtry=46 
- Fold22: mtry=46 
+ Fold22: mtry=48 
- Fold22: mtry=48 
+ Fold22: mtry=50 
- Fold22: mtry=50 
+ Fold22: mtry=52 
- Fold22: mtry=52 
+ Fold22: mtry=54 
- Fold22: mtry=54 
+ Fold22: mtry=56 
- Fold22: mtry=56 
+ Fold22: mtry=58 
- Fold22: mtry=58 
+ Fold22: mtry=60 
- Fold22: mtry=60 
+ Fold22: mtry=62 
- Fold22: mtry=62 
+ Fold22: mtry=64 
- Fold22: mtry=64 
+ Fold22: mtry=66 
- Fold22: mtry=66 
+ Fold22: mtry=68 
- Fold22: mtry=68 
+ Fold22: mtry=70 
- Fold22: mtry=70 
+ Fold22: mtry=72 
- Fold22: mtry=72 
+ Fold22: mtry=74 
- Fold22: mtry=74 
+ Fold22: mtry=76 
- Fold22: mtry=76 
+ Fold23: mtry= 2 
- Fold23: mtry= 2 
+ Fold23: mtry= 4 
- Fold23: mtry= 4 
+ Fold23: mtry= 6 
- Fold23: mtry= 6 
+ Fold23: mtry= 8 
- Fold23: mtry= 8 
+ Fold23: mtry=10 
- Fold23: mtry=10 
+ Fold23: mtry=12 
- Fold23: mtry=12 
+ Fold23: mtry=14 
- Fold23: mtry=14 
+ Fold23: mtry=16 
- Fold23: mtry=16 
+ Fold23: mtry=18 
- Fold23: mtry=18 
+ Fold23: mtry=20 
- Fold23: mtry=20 
+ Fold23: mtry=22 
- Fold23: mtry=22 
+ Fold23: mtry=24 
- Fold23: mtry=24 
+ Fold23: mtry=26 
- Fold23: mtry=26 
+ Fold23: mtry=28 
- Fold23: mtry=28 
+ Fold23: mtry=30 
- Fold23: mtry=30 
+ Fold23: mtry=32 
- Fold23: mtry=32 
+ Fold23: mtry=34 
- Fold23: mtry=34 
+ Fold23: mtry=36 
- Fold23: mtry=36 
+ Fold23: mtry=38 
- Fold23: mtry=38 
+ Fold23: mtry=40 
- Fold23: mtry=40 
+ Fold23: mtry=42 
- Fold23: mtry=42 
+ Fold23: mtry=44 
- Fold23: mtry=44 
+ Fold23: mtry=46 
- Fold23: mtry=46 
+ Fold23: mtry=48 
- Fold23: mtry=48 
+ Fold23: mtry=50 
- Fold23: mtry=50 
+ Fold23: mtry=52 
- Fold23: mtry=52 
+ Fold23: mtry=54 
- Fold23: mtry=54 
+ Fold23: mtry=56 
- Fold23: mtry=56 
+ Fold23: mtry=58 
- Fold23: mtry=58 
+ Fold23: mtry=60 
- Fold23: mtry=60 
+ Fold23: mtry=62 
- Fold23: mtry=62 
+ Fold23: mtry=64 
- Fold23: mtry=64 
+ Fold23: mtry=66 
- Fold23: mtry=66 
+ Fold23: mtry=68 
- Fold23: mtry=68 
+ Fold23: mtry=70 
- Fold23: mtry=70 
+ Fold23: mtry=72 
- Fold23: mtry=72 
+ Fold23: mtry=74 
- Fold23: mtry=74 
+ Fold23: mtry=76 
- Fold23: mtry=76 
+ Fold24: mtry= 2 
- Fold24: mtry= 2 
+ Fold24: mtry= 4 
- Fold24: mtry= 4 
+ Fold24: mtry= 6 
- Fold24: mtry= 6 
+ Fold24: mtry= 8 
- Fold24: mtry= 8 
+ Fold24: mtry=10 
- Fold24: mtry=10 
+ Fold24: mtry=12 
- Fold24: mtry=12 
+ Fold24: mtry=14 
- Fold24: mtry=14 
+ Fold24: mtry=16 
- Fold24: mtry=16 
+ Fold24: mtry=18 
- Fold24: mtry=18 
+ Fold24: mtry=20 
- Fold24: mtry=20 
+ Fold24: mtry=22 
- Fold24: mtry=22 
+ Fold24: mtry=24 
- Fold24: mtry=24 
+ Fold24: mtry=26 
- Fold24: mtry=26 
+ Fold24: mtry=28 
- Fold24: mtry=28 
+ Fold24: mtry=30 
- Fold24: mtry=30 
+ Fold24: mtry=32 
- Fold24: mtry=32 
+ Fold24: mtry=34 
- Fold24: mtry=34 
+ Fold24: mtry=36 
- Fold24: mtry=36 
+ Fold24: mtry=38 
- Fold24: mtry=38 
+ Fold24: mtry=40 
- Fold24: mtry=40 
+ Fold24: mtry=42 
- Fold24: mtry=42 
+ Fold24: mtry=44 
- Fold24: mtry=44 
+ Fold24: mtry=46 
- Fold24: mtry=46 
+ Fold24: mtry=48 
- Fold24: mtry=48 
+ Fold24: mtry=50 
- Fold24: mtry=50 
+ Fold24: mtry=52 
- Fold24: mtry=52 
+ Fold24: mtry=54 
- Fold24: mtry=54 
+ Fold24: mtry=56 
- Fold24: mtry=56 
+ Fold24: mtry=58 
- Fold24: mtry=58 
+ Fold24: mtry=60 
- Fold24: mtry=60 
+ Fold24: mtry=62 
- Fold24: mtry=62 
+ Fold24: mtry=64 
- Fold24: mtry=64 
+ Fold24: mtry=66 
- Fold24: mtry=66 
+ Fold24: mtry=68 
- Fold24: mtry=68 
+ Fold24: mtry=70 
- Fold24: mtry=70 
+ Fold24: mtry=72 
- Fold24: mtry=72 
+ Fold24: mtry=74 
- Fold24: mtry=74 
+ Fold24: mtry=76 
- Fold24: mtry=76 
+ Fold25: mtry= 2 
- Fold25: mtry= 2 
+ Fold25: mtry= 4 
- Fold25: mtry= 4 
+ Fold25: mtry= 6 
- Fold25: mtry= 6 
+ Fold25: mtry= 8 
- Fold25: mtry= 8 
+ Fold25: mtry=10 
- Fold25: mtry=10 
+ Fold25: mtry=12 
- Fold25: mtry=12 
+ Fold25: mtry=14 
- Fold25: mtry=14 
+ Fold25: mtry=16 
- Fold25: mtry=16 
+ Fold25: mtry=18 
- Fold25: mtry=18 
+ Fold25: mtry=20 
- Fold25: mtry=20 
+ Fold25: mtry=22 
- Fold25: mtry=22 
+ Fold25: mtry=24 
- Fold25: mtry=24 
+ Fold25: mtry=26 
- Fold25: mtry=26 
+ Fold25: mtry=28 
- Fold25: mtry=28 
+ Fold25: mtry=30 
- Fold25: mtry=30 
+ Fold25: mtry=32 
- Fold25: mtry=32 
+ Fold25: mtry=34 
- Fold25: mtry=34 
+ Fold25: mtry=36 
- Fold25: mtry=36 
+ Fold25: mtry=38 
- Fold25: mtry=38 
+ Fold25: mtry=40 
- Fold25: mtry=40 
+ Fold25: mtry=42 
- Fold25: mtry=42 
+ Fold25: mtry=44 
- Fold25: mtry=44 
+ Fold25: mtry=46 
- Fold25: mtry=46 
+ Fold25: mtry=48 
- Fold25: mtry=48 
+ Fold25: mtry=50 
- Fold25: mtry=50 
+ Fold25: mtry=52 
- Fold25: mtry=52 
+ Fold25: mtry=54 
- Fold25: mtry=54 
+ Fold25: mtry=56 
- Fold25: mtry=56 
+ Fold25: mtry=58 
- Fold25: mtry=58 
+ Fold25: mtry=60 
- Fold25: mtry=60 
+ Fold25: mtry=62 
- Fold25: mtry=62 
+ Fold25: mtry=64 
- Fold25: mtry=64 
+ Fold25: mtry=66 
- Fold25: mtry=66 
+ Fold25: mtry=68 
- Fold25: mtry=68 
+ Fold25: mtry=70 
- Fold25: mtry=70 
+ Fold25: mtry=72 
- Fold25: mtry=72 
+ Fold25: mtry=74 
- Fold25: mtry=74 
+ Fold25: mtry=76 
- Fold25: mtry=76 
+ Fold26: mtry= 2 
- Fold26: mtry= 2 
+ Fold26: mtry= 4 
- Fold26: mtry= 4 
+ Fold26: mtry= 6 
- Fold26: mtry= 6 
+ Fold26: mtry= 8 
- Fold26: mtry= 8 
+ Fold26: mtry=10 
- Fold26: mtry=10 
+ Fold26: mtry=12 
- Fold26: mtry=12 
+ Fold26: mtry=14 
- Fold26: mtry=14 
+ Fold26: mtry=16 
- Fold26: mtry=16 
+ Fold26: mtry=18 
- Fold26: mtry=18 
+ Fold26: mtry=20 
- Fold26: mtry=20 
+ Fold26: mtry=22 
- Fold26: mtry=22 
+ Fold26: mtry=24 
- Fold26: mtry=24 
+ Fold26: mtry=26 
- Fold26: mtry=26 
+ Fold26: mtry=28 
- Fold26: mtry=28 
+ Fold26: mtry=30 
- Fold26: mtry=30 
+ Fold26: mtry=32 
- Fold26: mtry=32 
+ Fold26: mtry=34 
- Fold26: mtry=34 
+ Fold26: mtry=36 
- Fold26: mtry=36 
+ Fold26: mtry=38 
- Fold26: mtry=38 
+ Fold26: mtry=40 
- Fold26: mtry=40 
+ Fold26: mtry=42 
- Fold26: mtry=42 
+ Fold26: mtry=44 
- Fold26: mtry=44 
+ Fold26: mtry=46 
- Fold26: mtry=46 
+ Fold26: mtry=48 
- Fold26: mtry=48 
+ Fold26: mtry=50 
- Fold26: mtry=50 
+ Fold26: mtry=52 
- Fold26: mtry=52 
+ Fold26: mtry=54 
- Fold26: mtry=54 
+ Fold26: mtry=56 
- Fold26: mtry=56 
+ Fold26: mtry=58 
- Fold26: mtry=58 
+ Fold26: mtry=60 
- Fold26: mtry=60 
+ Fold26: mtry=62 
- Fold26: mtry=62 
+ Fold26: mtry=64 
- Fold26: mtry=64 
+ Fold26: mtry=66 
- Fold26: mtry=66 
+ Fold26: mtry=68 
- Fold26: mtry=68 
+ Fold26: mtry=70 
- Fold26: mtry=70 
+ Fold26: mtry=72 
- Fold26: mtry=72 
+ Fold26: mtry=74 
- Fold26: mtry=74 
+ Fold26: mtry=76 
- Fold26: mtry=76 
+ Fold27: mtry= 2 
- Fold27: mtry= 2 
+ Fold27: mtry= 4 
- Fold27: mtry= 4 
+ Fold27: mtry= 6 
- Fold27: mtry= 6 
+ Fold27: mtry= 8 
- Fold27: mtry= 8 
+ Fold27: mtry=10 
- Fold27: mtry=10 
+ Fold27: mtry=12 
- Fold27: mtry=12 
+ Fold27: mtry=14 
- Fold27: mtry=14 
+ Fold27: mtry=16 
- Fold27: mtry=16 
+ Fold27: mtry=18 
- Fold27: mtry=18 
+ Fold27: mtry=20 
- Fold27: mtry=20 
+ Fold27: mtry=22 
- Fold27: mtry=22 
+ Fold27: mtry=24 
- Fold27: mtry=24 
+ Fold27: mtry=26 
- Fold27: mtry=26 
+ Fold27: mtry=28 
- Fold27: mtry=28 
+ Fold27: mtry=30 
- Fold27: mtry=30 
+ Fold27: mtry=32 
- Fold27: mtry=32 
+ Fold27: mtry=34 
- Fold27: mtry=34 
+ Fold27: mtry=36 
- Fold27: mtry=36 
+ Fold27: mtry=38 
- Fold27: mtry=38 
+ Fold27: mtry=40 
- Fold27: mtry=40 
+ Fold27: mtry=42 
- Fold27: mtry=42 
+ Fold27: mtry=44 
- Fold27: mtry=44 
+ Fold27: mtry=46 
- Fold27: mtry=46 
+ Fold27: mtry=48 
- Fold27: mtry=48 
+ Fold27: mtry=50 
- Fold27: mtry=50 
+ Fold27: mtry=52 
- Fold27: mtry=52 
+ Fold27: mtry=54 
- Fold27: mtry=54 
+ Fold27: mtry=56 
- Fold27: mtry=56 
+ Fold27: mtry=58 
- Fold27: mtry=58 
+ Fold27: mtry=60 
- Fold27: mtry=60 
+ Fold27: mtry=62 
- Fold27: mtry=62 
+ Fold27: mtry=64 
- Fold27: mtry=64 
+ Fold27: mtry=66 
- Fold27: mtry=66 
+ Fold27: mtry=68 
- Fold27: mtry=68 
+ Fold27: mtry=70 
- Fold27: mtry=70 
+ Fold27: mtry=72 
- Fold27: mtry=72 
+ Fold27: mtry=74 
- Fold27: mtry=74 
+ Fold27: mtry=76 
- Fold27: mtry=76 
+ Fold28: mtry= 2 
- Fold28: mtry= 2 
+ Fold28: mtry= 4 
- Fold28: mtry= 4 
+ Fold28: mtry= 6 
- Fold28: mtry= 6 
+ Fold28: mtry= 8 
- Fold28: mtry= 8 
+ Fold28: mtry=10 
- Fold28: mtry=10 
+ Fold28: mtry=12 
- Fold28: mtry=12 
+ Fold28: mtry=14 
- Fold28: mtry=14 
+ Fold28: mtry=16 
- Fold28: mtry=16 
+ Fold28: mtry=18 
- Fold28: mtry=18 
+ Fold28: mtry=20 
- Fold28: mtry=20 
+ Fold28: mtry=22 
- Fold28: mtry=22 
+ Fold28: mtry=24 
- Fold28: mtry=24 
+ Fold28: mtry=26 
- Fold28: mtry=26 
+ Fold28: mtry=28 
- Fold28: mtry=28 
+ Fold28: mtry=30 
- Fold28: mtry=30 
+ Fold28: mtry=32 
- Fold28: mtry=32 
+ Fold28: mtry=34 
- Fold28: mtry=34 
+ Fold28: mtry=36 
- Fold28: mtry=36 
+ Fold28: mtry=38 
- Fold28: mtry=38 
+ Fold28: mtry=40 
- Fold28: mtry=40 
+ Fold28: mtry=42 
- Fold28: mtry=42 
+ Fold28: mtry=44 
- Fold28: mtry=44 
+ Fold28: mtry=46 
- Fold28: mtry=46 
+ Fold28: mtry=48 
- Fold28: mtry=48 
+ Fold28: mtry=50 
- Fold28: mtry=50 
+ Fold28: mtry=52 
- Fold28: mtry=52 
+ Fold28: mtry=54 
- Fold28: mtry=54 
+ Fold28: mtry=56 
- Fold28: mtry=56 
+ Fold28: mtry=58 
- Fold28: mtry=58 
+ Fold28: mtry=60 
- Fold28: mtry=60 
+ Fold28: mtry=62 
- Fold28: mtry=62 
+ Fold28: mtry=64 
- Fold28: mtry=64 
+ Fold28: mtry=66 
- Fold28: mtry=66 
+ Fold28: mtry=68 
- Fold28: mtry=68 
+ Fold28: mtry=70 
- Fold28: mtry=70 
+ Fold28: mtry=72 
- Fold28: mtry=72 
+ Fold28: mtry=74 
- Fold28: mtry=74 
+ Fold28: mtry=76 
- Fold28: mtry=76 
Aggregating results
Selecting tuning parameters
Fitting mtry = 66 on full training set
# View results
print(rf_model)
Random Forest 

28 samples
77 predictors

Pre-processing: scaled (77), centered (77) 
Resampling: Leave-One-Out Cross-Validation 
Summary of sample sizes: 27, 27, 27, 27, 27, 27, ... 
Resampling results across tuning parameters:

  mtry  RMSE       Rsquared   MAE       
   2    0.1319076  0.7307622  0.10400154
   4    0.1247448  0.7345051  0.10045831
   6    0.1173711  0.7516734  0.09529038
   8    0.1111302  0.7807532  0.08979518
  10    0.1101170  0.7777265  0.08891742
  12    0.1129948  0.7573879  0.09218351
  14    0.1097014  0.7650401  0.09202429
  16    0.1117997  0.7489663  0.09291841
  18    0.1082932  0.7662454  0.08936235
  20    0.1062386  0.7761468  0.08789160
  22    0.1036523  0.7842697  0.08666169
  24    0.1033955  0.7873550  0.08715356
  26    0.1056844  0.7758383  0.08863065
  28    0.1083445  0.7587687  0.09065624
  30    0.1055486  0.7692320  0.08782592
  32    0.1067974  0.7647826  0.09035509
  34    0.1048251  0.7738961  0.08809291
  36    0.1031659  0.7835676  0.08621945
  38    0.1021361  0.7887114  0.08708167
  40    0.1034123  0.7771168  0.08734699
  42    0.1025685  0.7835034  0.08709742
  44    0.1052106  0.7646120  0.08897143
  46    0.1045910  0.7718242  0.08898486
  48    0.1042532  0.7708851  0.08819778
  50    0.1015653  0.7847023  0.08687486
  52    0.1050730  0.7684176  0.08914126
  54    0.1028900  0.7807736  0.08708026
  56    0.1034407  0.7761208  0.08852871
  58    0.1015831  0.7876578  0.08736605
  60    0.1016937  0.7832458  0.08727626
  62    0.1041686  0.7693761  0.08880747
  64    0.1049347  0.7638845  0.09081583
  66    0.1014847  0.7858326  0.08689145
  68    0.1029796  0.7755602  0.08886616
  70    0.1041884  0.7707315  0.08921879
  72    0.1035858  0.7732422  0.08916650
  74    0.1035339  0.7751298  0.09004063
  76    0.1041359  0.7704159  0.08982766

RMSE was used to select the optimal model using the smallest value.
The final value used for the model was mtry = 66.
plot(rf_model)  # Plot performance across hyperparameters
varImpPlot(rf_model$finalModel)  # Plot variable importance

Gradient boosting

gbm_grid <- expand.grid(
  n.trees = c(50, 100, 200),           # Fewer trees
  interaction.depth = c(1, 2, 3),      # Much smaller tree depth
  shrinkage = c(0.01, 0.05, 0.1),      # Keep these values
  n.minobsinnode = c(1, 3, 5)          # Smaller minimum observations
)

gbm_model <- train(
  mean_trans_docs ~ ., 
  data = data_models, 
  method = "gbm",
  preProc = c('scale', 'center'),
  trControl = control,
  tuneGrid = gbm_grid)
+ Fold01: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0438             nan     0.0100    0.0005
     2        0.0434             nan     0.0100    0.0002
     3        0.0428             nan     0.0100    0.0006
     4        0.0423             nan     0.0100    0.0005
     5        0.0417             nan     0.0100    0.0005
     6        0.0411             nan     0.0100    0.0006
     7        0.0406             nan     0.0100    0.0004
     8        0.0400             nan     0.0100    0.0004
     9        0.0396             nan     0.0100    0.0002
    10        0.0393             nan     0.0100    0.0003
    20        0.0349             nan     0.0100    0.0001
    40        0.0277             nan     0.0100    0.0002
    60        0.0219             nan     0.0100    0.0002
    80        0.0175             nan     0.0100    0.0002
   100        0.0142             nan     0.0100    0.0000
   120        0.0120             nan     0.0100    0.0000
   140        0.0101             nan     0.0100    0.0001
   160        0.0085             nan     0.0100    0.0001
   180        0.0071             nan     0.0100    0.0001
   200        0.0061             nan     0.0100    0.0000

- Fold01: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold01: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0437             nan     0.0100    0.0006
     2        0.0431             nan     0.0100    0.0004
     3        0.0426             nan     0.0100    0.0001
     4        0.0421             nan     0.0100    0.0005
     5        0.0415             nan     0.0100    0.0003
     6        0.0411             nan     0.0100    0.0004
     7        0.0406             nan     0.0100    0.0003
     8        0.0400             nan     0.0100    0.0004
     9        0.0394             nan     0.0100    0.0003
    10        0.0387             nan     0.0100    0.0006
    20        0.0345             nan     0.0100    0.0004
    40        0.0273             nan     0.0100    0.0003
    60        0.0218             nan     0.0100    0.0002
    80        0.0174             nan     0.0100    0.0001
   100        0.0141             nan     0.0100    0.0001
   120        0.0119             nan     0.0100    0.0001
   140        0.0100             nan     0.0100    0.0000
   160        0.0083             nan     0.0100    0.0001
   180        0.0069             nan     0.0100    0.0001
   200        0.0058             nan     0.0100    0.0000

- Fold01: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold01: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0441             nan     0.0100    0.0001
     2        0.0436             nan     0.0100    0.0004
     3        0.0432             nan     0.0100    0.0002
     4        0.0426             nan     0.0100    0.0006
     5        0.0422             nan     0.0100   -0.0000
     6        0.0416             nan     0.0100    0.0005
     7        0.0413             nan     0.0100    0.0003
     8        0.0408             nan     0.0100    0.0005
     9        0.0402             nan     0.0100    0.0006
    10        0.0398             nan     0.0100    0.0002
    20        0.0360             nan     0.0100   -0.0000
    40        0.0287             nan     0.0100   -0.0001
    60        0.0235             nan     0.0100    0.0001
    80        0.0192             nan     0.0100    0.0002
   100        0.0162             nan     0.0100   -0.0000
   120        0.0139             nan     0.0100   -0.0000
   140        0.0120             nan     0.0100    0.0001
   160        0.0104             nan     0.0100    0.0001
   180        0.0092             nan     0.0100   -0.0000
   200        0.0081             nan     0.0100    0.0000

- Fold01: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold01: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0441             nan     0.0100    0.0001
     2        0.0434             nan     0.0100    0.0005
     3        0.0427             nan     0.0100    0.0005
     4        0.0421             nan     0.0100    0.0005
     5        0.0415             nan     0.0100    0.0005
     6        0.0410             nan     0.0100    0.0005
     7        0.0404             nan     0.0100    0.0006
     8        0.0398             nan     0.0100    0.0003
     9        0.0392             nan     0.0100    0.0007
    10        0.0386             nan     0.0100    0.0004
    20        0.0334             nan     0.0100    0.0006
    40        0.0248             nan     0.0100    0.0002
    60        0.0189             nan     0.0100    0.0001
    80        0.0144             nan     0.0100    0.0002
   100        0.0113             nan     0.0100    0.0001
   120        0.0091             nan     0.0100    0.0000
   140        0.0073             nan     0.0100    0.0000
   160        0.0058             nan     0.0100    0.0000
   180        0.0047             nan     0.0100    0.0000
   200        0.0036             nan     0.0100    0.0000

- Fold01: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold01: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0438             nan     0.0100    0.0004
     2        0.0431             nan     0.0100    0.0004
     3        0.0425             nan     0.0100    0.0006
     4        0.0418             nan     0.0100    0.0007
     5        0.0414             nan     0.0100    0.0002
     6        0.0409             nan     0.0100    0.0004
     7        0.0404             nan     0.0100    0.0001
     8        0.0398             nan     0.0100    0.0003
     9        0.0393             nan     0.0100    0.0004
    10        0.0386             nan     0.0100    0.0005
    20        0.0336             nan     0.0100    0.0003
    40        0.0257             nan     0.0100    0.0003
    60        0.0202             nan     0.0100    0.0002
    80        0.0158             nan     0.0100    0.0002
   100        0.0126             nan     0.0100    0.0000
   120        0.0099             nan     0.0100    0.0001
   140        0.0081             nan     0.0100    0.0000
   160        0.0066             nan     0.0100    0.0000
   180        0.0054             nan     0.0100   -0.0000
   200        0.0044             nan     0.0100    0.0000

- Fold01: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold01: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0441             nan     0.0100    0.0004
     2        0.0435             nan     0.0100    0.0005
     3        0.0432             nan     0.0100   -0.0002
     4        0.0428             nan     0.0100    0.0001
     5        0.0423             nan     0.0100    0.0005
     6        0.0418             nan     0.0100    0.0005
     7        0.0411             nan     0.0100    0.0006
     8        0.0405             nan     0.0100    0.0002
     9        0.0399             nan     0.0100    0.0005
    10        0.0396             nan     0.0100    0.0003
    20        0.0351             nan     0.0100    0.0000
    40        0.0285             nan     0.0100    0.0004
    60        0.0228             nan     0.0100    0.0002
    80        0.0187             nan     0.0100    0.0002
   100        0.0159             nan     0.0100    0.0001
   120        0.0134             nan     0.0100    0.0001
   140        0.0113             nan     0.0100    0.0001
   160        0.0102             nan     0.0100    0.0000
   180        0.0092             nan     0.0100    0.0000
   200        0.0081             nan     0.0100    0.0000

- Fold01: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold01: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0438             nan     0.0100    0.0007
     2        0.0431             nan     0.0100    0.0004
     3        0.0425             nan     0.0100    0.0006
     4        0.0418             nan     0.0100    0.0003
     5        0.0411             nan     0.0100    0.0006
     6        0.0404             nan     0.0100    0.0005
     7        0.0399             nan     0.0100    0.0002
     8        0.0395             nan     0.0100    0.0003
     9        0.0386             nan     0.0100    0.0011
    10        0.0379             nan     0.0100    0.0002
    20        0.0328             nan     0.0100    0.0005
    40        0.0245             nan     0.0100    0.0005
    60        0.0181             nan     0.0100    0.0003
    80        0.0137             nan     0.0100    0.0001
   100        0.0106             nan     0.0100    0.0000
   120        0.0082             nan     0.0100    0.0001
   140        0.0065             nan     0.0100    0.0000
   160        0.0051             nan     0.0100    0.0000
   180        0.0040             nan     0.0100   -0.0000
   200        0.0031             nan     0.0100    0.0000

- Fold01: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold01: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0438             nan     0.0100    0.0004
     2        0.0431             nan     0.0100    0.0005
     3        0.0425             nan     0.0100    0.0006
     4        0.0419             nan     0.0100    0.0005
     5        0.0415             nan     0.0100    0.0002
     6        0.0409             nan     0.0100    0.0002
     7        0.0403             nan     0.0100    0.0005
     8        0.0398             nan     0.0100    0.0004
     9        0.0394             nan     0.0100    0.0004
    10        0.0389             nan     0.0100    0.0003
    20        0.0335             nan     0.0100    0.0006
    40        0.0256             nan     0.0100    0.0002
    60        0.0193             nan     0.0100    0.0003
    80        0.0151             nan     0.0100    0.0002
   100        0.0119             nan     0.0100    0.0001
   120        0.0095             nan     0.0100    0.0001
   140        0.0074             nan     0.0100    0.0001
   160        0.0061             nan     0.0100    0.0000
   180        0.0050             nan     0.0100   -0.0000
   200        0.0042             nan     0.0100    0.0000

- Fold01: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold01: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0438             nan     0.0100    0.0005
     2        0.0434             nan     0.0100    0.0004
     3        0.0428             nan     0.0100    0.0006
     4        0.0423             nan     0.0100    0.0004
     5        0.0418             nan     0.0100    0.0005
     6        0.0412             nan     0.0100    0.0005
     7        0.0408             nan     0.0100    0.0005
     8        0.0401             nan     0.0100    0.0006
     9        0.0398             nan     0.0100    0.0003
    10        0.0392             nan     0.0100    0.0006
    20        0.0348             nan     0.0100    0.0005
    40        0.0274             nan     0.0100    0.0002
    60        0.0222             nan     0.0100    0.0002
    80        0.0180             nan     0.0100    0.0002
   100        0.0151             nan     0.0100    0.0001
   120        0.0129             nan     0.0100    0.0000
   140        0.0113             nan     0.0100    0.0001
   160        0.0097             nan     0.0100    0.0001
   180        0.0086             nan     0.0100    0.0000
   200        0.0076             nan     0.0100    0.0000

- Fold01: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold01: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0431             nan     0.0500    0.0010
     2        0.0403             nan     0.0500    0.0029
     3        0.0384             nan     0.0500    0.0013
     4        0.0358             nan     0.0500    0.0026
     5        0.0338             nan     0.0500    0.0015
     6        0.0325             nan     0.0500    0.0011
     7        0.0312             nan     0.0500   -0.0000
     8        0.0303             nan     0.0500    0.0001
     9        0.0290             nan     0.0500    0.0007
    10        0.0275             nan     0.0500    0.0007
    20        0.0170             nan     0.0500    0.0006
    40        0.0064             nan     0.0500   -0.0000
    60        0.0031             nan     0.0500   -0.0001
    80        0.0016             nan     0.0500   -0.0000
   100        0.0011             nan     0.0500   -0.0000
   120        0.0007             nan     0.0500   -0.0000
   140        0.0004             nan     0.0500   -0.0000
   160        0.0003             nan     0.0500   -0.0000
   180        0.0002             nan     0.0500    0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold01: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold01: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0422             nan     0.0500    0.0016
     2        0.0390             nan     0.0500    0.0025
     3        0.0359             nan     0.0500    0.0021
     4        0.0331             nan     0.0500    0.0018
     5        0.0308             nan     0.0500    0.0018
     6        0.0299             nan     0.0500    0.0005
     7        0.0282             nan     0.0500    0.0015
     8        0.0268             nan     0.0500    0.0012
     9        0.0251             nan     0.0500    0.0014
    10        0.0241             nan     0.0500    0.0010
    20        0.0136             nan     0.0500    0.0004
    40        0.0060             nan     0.0500    0.0002
    60        0.0034             nan     0.0500    0.0001
    80        0.0018             nan     0.0500   -0.0000
   100        0.0012             nan     0.0500   -0.0000
   120        0.0008             nan     0.0500    0.0000
   140        0.0005             nan     0.0500    0.0000
   160        0.0003             nan     0.0500    0.0000
   180        0.0002             nan     0.0500    0.0000
   200        0.0002             nan     0.0500   -0.0000

- Fold01: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold01: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0424             nan     0.0500    0.0011
     2        0.0416             nan     0.0500   -0.0011
     3        0.0393             nan     0.0500    0.0027
     4        0.0378             nan     0.0500    0.0015
     5        0.0349             nan     0.0500    0.0014
     6        0.0330             nan     0.0500    0.0020
     7        0.0314             nan     0.0500    0.0020
     8        0.0295             nan     0.0500    0.0018
     9        0.0279             nan     0.0500    0.0013
    10        0.0262             nan     0.0500    0.0016
    20        0.0163             nan     0.0500    0.0003
    40        0.0084             nan     0.0500    0.0002
    60        0.0053             nan     0.0500    0.0001
    80        0.0032             nan     0.0500   -0.0000
   100        0.0024             nan     0.0500   -0.0001
   120        0.0018             nan     0.0500   -0.0000
   140        0.0014             nan     0.0500   -0.0000
   160        0.0011             nan     0.0500   -0.0000
   180        0.0009             nan     0.0500    0.0000
   200        0.0006             nan     0.0500   -0.0000

- Fold01: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold01: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0415             nan     0.0500    0.0017
     2        0.0391             nan     0.0500    0.0010
     3        0.0358             nan     0.0500    0.0028
     4        0.0329             nan     0.0500    0.0026
     5        0.0308             nan     0.0500    0.0020
     6        0.0285             nan     0.0500    0.0025
     7        0.0274             nan     0.0500    0.0006
     8        0.0250             nan     0.0500    0.0020
     9        0.0232             nan     0.0500    0.0014
    10        0.0220             nan     0.0500    0.0007
    20        0.0116             nan     0.0500    0.0009
    40        0.0035             nan     0.0500    0.0001
    60        0.0013             nan     0.0500    0.0000
    80        0.0005             nan     0.0500    0.0000
   100        0.0002             nan     0.0500    0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0001             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold01: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold01: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0419             nan     0.0500    0.0025
     2        0.0386             nan     0.0500    0.0021
     3        0.0362             nan     0.0500    0.0022
     4        0.0332             nan     0.0500    0.0024
     5        0.0306             nan     0.0500    0.0008
     6        0.0292             nan     0.0500    0.0007
     7        0.0268             nan     0.0500    0.0022
     8        0.0250             nan     0.0500    0.0011
     9        0.0232             nan     0.0500    0.0019
    10        0.0213             nan     0.0500    0.0013
    20        0.0116             nan     0.0500    0.0005
    40        0.0041             nan     0.0500    0.0001
    60        0.0015             nan     0.0500   -0.0000
    80        0.0008             nan     0.0500    0.0000
   100        0.0004             nan     0.0500    0.0000
   120        0.0002             nan     0.0500   -0.0000
   140        0.0001             nan     0.0500   -0.0000
   160        0.0001             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500    0.0000

- Fold01: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold01: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0418             nan     0.0500    0.0022
     2        0.0401             nan     0.0500    0.0002
     3        0.0377             nan     0.0500    0.0023
     4        0.0363             nan     0.0500    0.0007
     5        0.0346             nan     0.0500    0.0014
     6        0.0332             nan     0.0500    0.0017
     7        0.0316             nan     0.0500    0.0012
     8        0.0303             nan     0.0500    0.0011
     9        0.0286             nan     0.0500    0.0014
    10        0.0270             nan     0.0500    0.0003
    20        0.0170             nan     0.0500    0.0002
    40        0.0087             nan     0.0500    0.0001
    60        0.0058             nan     0.0500   -0.0000
    80        0.0043             nan     0.0500   -0.0000
   100        0.0032             nan     0.0500   -0.0000
   120        0.0023             nan     0.0500    0.0000
   140        0.0015             nan     0.0500    0.0000
   160        0.0011             nan     0.0500    0.0000
   180        0.0008             nan     0.0500   -0.0000
   200        0.0006             nan     0.0500   -0.0000

- Fold01: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold01: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0432             nan     0.0500   -0.0007
     2        0.0400             nan     0.0500    0.0035
     3        0.0361             nan     0.0500    0.0026
     4        0.0337             nan     0.0500    0.0026
     5        0.0305             nan     0.0500    0.0024
     6        0.0277             nan     0.0500    0.0022
     7        0.0253             nan     0.0500    0.0023
     8        0.0240             nan     0.0500    0.0004
     9        0.0219             nan     0.0500    0.0011
    10        0.0206             nan     0.0500    0.0015
    20        0.0101             nan     0.0500    0.0006
    40        0.0032             nan     0.0500    0.0001
    60        0.0010             nan     0.0500   -0.0000
    80        0.0005             nan     0.0500   -0.0000
   100        0.0002             nan     0.0500   -0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0000             nan     0.0500    0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold01: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold01: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0413             nan     0.0500    0.0039
     2        0.0382             nan     0.0500    0.0032
     3        0.0358             nan     0.0500    0.0020
     4        0.0331             nan     0.0500    0.0025
     5        0.0313             nan     0.0500    0.0017
     6        0.0298             nan     0.0500    0.0007
     7        0.0275             nan     0.0500    0.0019
     8        0.0246             nan     0.0500    0.0023
     9        0.0227             nan     0.0500    0.0004
    10        0.0208             nan     0.0500    0.0015
    20        0.0120             nan     0.0500    0.0008
    40        0.0038             nan     0.0500    0.0000
    60        0.0015             nan     0.0500    0.0000
    80        0.0009             nan     0.0500   -0.0000
   100        0.0005             nan     0.0500    0.0000
   120        0.0003             nan     0.0500   -0.0000
   140        0.0002             nan     0.0500   -0.0000
   160        0.0001             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold01: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold01: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0416             nan     0.0500    0.0022
     2        0.0397             nan     0.0500    0.0012
     3        0.0380             nan     0.0500    0.0014
     4        0.0353             nan     0.0500    0.0024
     5        0.0334             nan     0.0500    0.0006
     6        0.0312             nan     0.0500    0.0014
     7        0.0296             nan     0.0500    0.0007
     8        0.0281             nan     0.0500    0.0000
     9        0.0262             nan     0.0500    0.0018
    10        0.0243             nan     0.0500    0.0006
    20        0.0155             nan     0.0500    0.0005
    40        0.0087             nan     0.0500   -0.0001
    60        0.0051             nan     0.0500    0.0000
    80        0.0039             nan     0.0500   -0.0000
   100        0.0028             nan     0.0500   -0.0000
   120        0.0018             nan     0.0500    0.0000
   140        0.0013             nan     0.0500    0.0000
   160        0.0009             nan     0.0500    0.0000
   180        0.0006             nan     0.0500    0.0000
   200        0.0005             nan     0.0500   -0.0000

- Fold01: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold01: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0409             nan     0.1000    0.0019
     2        0.0366             nan     0.1000    0.0032
     3        0.0344             nan     0.1000   -0.0012
     4        0.0299             nan     0.1000    0.0026
     5        0.0277             nan     0.1000    0.0003
     6        0.0241             nan     0.1000    0.0031
     7        0.0223             nan     0.1000    0.0001
     8        0.0211             nan     0.1000   -0.0003
     9        0.0183             nan     0.1000    0.0025
    10        0.0163             nan     0.1000    0.0019
    20        0.0072             nan     0.1000    0.0005
    40        0.0021             nan     0.1000   -0.0000
    60        0.0008             nan     0.1000    0.0000
    80        0.0003             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0001             nan     0.1000    0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold01: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold01: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0400             nan     0.1000    0.0030
     2        0.0353             nan     0.1000    0.0033
     3        0.0312             nan     0.1000    0.0039
     4        0.0273             nan     0.1000    0.0030
     5        0.0251             nan     0.1000    0.0021
     6        0.0231             nan     0.1000    0.0008
     7        0.0203             nan     0.1000    0.0026
     8        0.0186             nan     0.1000    0.0019
     9        0.0169             nan     0.1000    0.0017
    10        0.0157             nan     0.1000    0.0013
    20        0.0084             nan     0.1000   -0.0001
    40        0.0023             nan     0.1000    0.0002
    60        0.0007             nan     0.1000    0.0000
    80        0.0003             nan     0.1000   -0.0000
   100        0.0002             nan     0.1000   -0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold01: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold01: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0402             nan     0.1000    0.0037
     2        0.0357             nan     0.1000    0.0041
     3        0.0307             nan     0.1000    0.0032
     4        0.0273             nan     0.1000    0.0030
     5        0.0250             nan     0.1000    0.0003
     6        0.0227             nan     0.1000    0.0022
     7        0.0200             nan     0.1000    0.0019
     8        0.0193             nan     0.1000   -0.0006
     9        0.0172             nan     0.1000    0.0004
    10        0.0160             nan     0.1000    0.0006
    20        0.0083             nan     0.1000    0.0006
    40        0.0032             nan     0.1000    0.0001
    60        0.0016             nan     0.1000   -0.0000
    80        0.0008             nan     0.1000   -0.0000
   100        0.0005             nan     0.1000   -0.0000
   120        0.0003             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000    0.0000
   180        0.0001             nan     0.1000    0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold01: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold01: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0368             nan     0.1000    0.0068
     2        0.0305             nan     0.1000    0.0041
     3        0.0271             nan     0.1000    0.0030
     4        0.0238             nan     0.1000    0.0033
     5        0.0211             nan     0.1000   -0.0002
     6        0.0176             nan     0.1000    0.0030
     7        0.0152             nan     0.1000    0.0020
     8        0.0131             nan     0.1000    0.0013
     9        0.0113             nan     0.1000    0.0017
    10        0.0098             nan     0.1000    0.0005
    20        0.0039             nan     0.1000    0.0003
    40        0.0006             nan     0.1000    0.0000
    60        0.0002             nan     0.1000    0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000    0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold01: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold01: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0395             nan     0.1000    0.0040
     2        0.0330             nan     0.1000    0.0055
     3        0.0295             nan     0.1000    0.0043
     4        0.0251             nan     0.1000    0.0030
     5        0.0213             nan     0.1000    0.0017
     6        0.0184             nan     0.1000    0.0020
     7        0.0159             nan     0.1000    0.0018
     8        0.0143             nan     0.1000    0.0010
     9        0.0128             nan     0.1000    0.0003
    10        0.0117             nan     0.1000    0.0009
    20        0.0039             nan     0.1000    0.0001
    40        0.0008             nan     0.1000    0.0000
    60        0.0002             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000    0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000    0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold01: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold01: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0389             nan     0.1000    0.0045
     2        0.0360             nan     0.1000    0.0018
     3        0.0325             nan     0.1000    0.0029
     4        0.0286             nan     0.1000    0.0037
     5        0.0253             nan     0.1000    0.0011
     6        0.0223             nan     0.1000    0.0012
     7        0.0205             nan     0.1000    0.0010
     8        0.0180             nan     0.1000    0.0011
     9        0.0165             nan     0.1000    0.0012
    10        0.0152             nan     0.1000    0.0007
    20        0.0076             nan     0.1000    0.0000
    40        0.0030             nan     0.1000    0.0001
    60        0.0011             nan     0.1000    0.0000
    80        0.0006             nan     0.1000   -0.0000
   100        0.0003             nan     0.1000   -0.0000
   120        0.0002             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000    0.0000
   160        0.0001             nan     0.1000    0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold01: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold01: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0375             nan     0.1000    0.0051
     2        0.0326             nan     0.1000    0.0036
     3        0.0269             nan     0.1000    0.0047
     4        0.0224             nan     0.1000    0.0039
     5        0.0186             nan     0.1000    0.0022
     6        0.0163             nan     0.1000    0.0023
     7        0.0146             nan     0.1000    0.0006
     8        0.0125             nan     0.1000    0.0015
     9        0.0113             nan     0.1000    0.0012
    10        0.0105             nan     0.1000   -0.0004
    20        0.0032             nan     0.1000    0.0004
    40        0.0005             nan     0.1000   -0.0000
    60        0.0001             nan     0.1000   -0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000    0.0000
   180        0.0000             nan     0.1000    0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold01: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold01: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0353             nan     0.1000    0.0049
     2        0.0304             nan     0.1000    0.0023
     3        0.0257             nan     0.1000    0.0023
     4        0.0230             nan     0.1000    0.0011
     5        0.0200             nan     0.1000    0.0011
     6        0.0168             nan     0.1000    0.0021
     7        0.0143             nan     0.1000    0.0018
     8        0.0134             nan     0.1000    0.0000
     9        0.0121             nan     0.1000    0.0009
    10        0.0106             nan     0.1000    0.0013
    20        0.0045             nan     0.1000   -0.0003
    40        0.0013             nan     0.1000   -0.0001
    60        0.0003             nan     0.1000    0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000    0.0000
   120        0.0000             nan     0.1000    0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold01: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold01: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0391             nan     0.1000    0.0054
     2        0.0350             nan     0.1000    0.0031
     3        0.0309             nan     0.1000    0.0036
     4        0.0288             nan     0.1000    0.0015
     5        0.0258             nan     0.1000    0.0020
     6        0.0237             nan     0.1000    0.0015
     7        0.0218             nan     0.1000    0.0013
     8        0.0199             nan     0.1000    0.0004
     9        0.0178             nan     0.1000    0.0010
    10        0.0170             nan     0.1000   -0.0007
    20        0.0086             nan     0.1000    0.0003
    40        0.0029             nan     0.1000    0.0001
    60        0.0013             nan     0.1000    0.0000
    80        0.0007             nan     0.1000    0.0000
   100        0.0003             nan     0.1000   -0.0000
   120        0.0002             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold01: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold02: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0433             nan     0.0100    0.0004
     2        0.0430             nan     0.0100    0.0002
     3        0.0425             nan     0.0100    0.0004
     4        0.0418             nan     0.0100    0.0007
     5        0.0414             nan     0.0100    0.0003
     6        0.0408             nan     0.0100    0.0005
     7        0.0402             nan     0.0100    0.0006
     8        0.0397             nan     0.0100    0.0005
     9        0.0392             nan     0.0100    0.0001
    10        0.0388             nan     0.0100    0.0001
    20        0.0344             nan     0.0100    0.0003
    40        0.0268             nan     0.0100    0.0002
    60        0.0222             nan     0.0100    0.0003
    80        0.0181             nan     0.0100    0.0001
   100        0.0147             nan     0.0100    0.0002
   120        0.0120             nan     0.0100    0.0001
   140        0.0101             nan     0.0100    0.0001
   160        0.0085             nan     0.0100    0.0000
   180        0.0073             nan     0.0100    0.0001
   200        0.0063             nan     0.0100   -0.0000

- Fold02: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold02: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0431             nan     0.0100    0.0006
     2        0.0425             nan     0.0100    0.0007
     3        0.0419             nan     0.0100    0.0006
     4        0.0415             nan     0.0100    0.0004
     5        0.0410             nan     0.0100    0.0005
     6        0.0406             nan     0.0100    0.0002
     7        0.0403             nan     0.0100   -0.0000
     8        0.0398             nan     0.0100    0.0005
     9        0.0392             nan     0.0100    0.0005
    10        0.0386             nan     0.0100    0.0005
    20        0.0351             nan     0.0100    0.0001
    40        0.0275             nan     0.0100    0.0003
    60        0.0220             nan     0.0100    0.0001
    80        0.0178             nan     0.0100    0.0001
   100        0.0147             nan     0.0100    0.0001
   120        0.0124             nan     0.0100    0.0001
   140        0.0103             nan     0.0100    0.0000
   160        0.0087             nan     0.0100    0.0001
   180        0.0076             nan     0.0100    0.0000
   200        0.0065             nan     0.0100   -0.0000

- Fold02: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold02: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0432             nan     0.0100    0.0005
     2        0.0425             nan     0.0100    0.0006
     3        0.0419             nan     0.0100    0.0005
     4        0.0413             nan     0.0100    0.0006
     5        0.0409             nan     0.0100    0.0001
     6        0.0406             nan     0.0100   -0.0000
     7        0.0402             nan     0.0100    0.0004
     8        0.0396             nan     0.0100    0.0005
     9        0.0393             nan     0.0100    0.0003
    10        0.0388             nan     0.0100    0.0004
    20        0.0343             nan     0.0100    0.0005
    40        0.0277             nan     0.0100    0.0003
    60        0.0226             nan     0.0100    0.0001
    80        0.0186             nan     0.0100    0.0001
   100        0.0155             nan     0.0100    0.0001
   120        0.0132             nan     0.0100    0.0001
   140        0.0115             nan     0.0100    0.0000
   160        0.0101             nan     0.0100   -0.0001
   180        0.0089             nan     0.0100   -0.0000
   200        0.0080             nan     0.0100    0.0000

- Fold02: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold02: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0434             nan     0.0100    0.0001
     2        0.0430             nan     0.0100   -0.0000
     3        0.0424             nan     0.0100    0.0006
     4        0.0417             nan     0.0100    0.0004
     5        0.0413             nan     0.0100    0.0003
     6        0.0408             nan     0.0100    0.0005
     7        0.0405             nan     0.0100    0.0001
     8        0.0401             nan     0.0100    0.0005
     9        0.0393             nan     0.0100    0.0008
    10        0.0387             nan     0.0100    0.0004
    20        0.0337             nan     0.0100    0.0005
    40        0.0259             nan     0.0100    0.0004
    60        0.0198             nan     0.0100    0.0001
    80        0.0152             nan     0.0100    0.0000
   100        0.0117             nan     0.0100    0.0001
   120        0.0095             nan     0.0100    0.0000
   140        0.0076             nan     0.0100    0.0001
   160        0.0062             nan     0.0100    0.0000
   180        0.0050             nan     0.0100    0.0000
   200        0.0040             nan     0.0100    0.0000

- Fold02: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold02: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0430             nan     0.0100    0.0007
     2        0.0425             nan     0.0100    0.0003
     3        0.0417             nan     0.0100    0.0009
     4        0.0415             nan     0.0100    0.0000
     5        0.0410             nan     0.0100    0.0005
     6        0.0403             nan     0.0100    0.0004
     7        0.0399             nan     0.0100    0.0002
     8        0.0393             nan     0.0100    0.0006
     9        0.0387             nan     0.0100    0.0004
    10        0.0381             nan     0.0100    0.0006
    20        0.0333             nan     0.0100    0.0003
    40        0.0252             nan     0.0100    0.0002
    60        0.0204             nan     0.0100    0.0002
    80        0.0160             nan     0.0100    0.0001
   100        0.0127             nan     0.0100    0.0001
   120        0.0100             nan     0.0100    0.0001
   140        0.0081             nan     0.0100    0.0001
   160        0.0066             nan     0.0100    0.0001
   180        0.0054             nan     0.0100    0.0001
   200        0.0045             nan     0.0100    0.0000

- Fold02: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold02: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0432             nan     0.0100    0.0006
     2        0.0428             nan     0.0100    0.0002
     3        0.0422             nan     0.0100    0.0004
     4        0.0417             nan     0.0100    0.0005
     5        0.0411             nan     0.0100    0.0006
     6        0.0404             nan     0.0100    0.0005
     7        0.0400             nan     0.0100    0.0003
     8        0.0396             nan     0.0100    0.0004
     9        0.0392             nan     0.0100    0.0001
    10        0.0386             nan     0.0100    0.0005
    20        0.0341             nan     0.0100    0.0004
    40        0.0274             nan     0.0100    0.0001
    60        0.0223             nan     0.0100    0.0003
    80        0.0186             nan     0.0100    0.0002
   100        0.0158             nan     0.0100    0.0001
   120        0.0136             nan     0.0100    0.0001
   140        0.0117             nan     0.0100    0.0000
   160        0.0102             nan     0.0100   -0.0000
   180        0.0090             nan     0.0100    0.0000
   200        0.0081             nan     0.0100    0.0000

- Fold02: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold02: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0431             nan     0.0100    0.0007
     2        0.0422             nan     0.0100    0.0006
     3        0.0415             nan     0.0100    0.0008
     4        0.0408             nan     0.0100    0.0004
     5        0.0404             nan     0.0100    0.0002
     6        0.0397             nan     0.0100    0.0006
     7        0.0391             nan     0.0100    0.0005
     8        0.0386             nan     0.0100    0.0004
     9        0.0379             nan     0.0100    0.0006
    10        0.0375             nan     0.0100    0.0003
    20        0.0322             nan     0.0100    0.0003
    40        0.0238             nan     0.0100    0.0003
    60        0.0178             nan     0.0100    0.0002
    80        0.0134             nan     0.0100    0.0001
   100        0.0102             nan     0.0100    0.0001
   120        0.0077             nan     0.0100    0.0001
   140        0.0060             nan     0.0100    0.0001
   160        0.0046             nan     0.0100   -0.0000
   180        0.0037             nan     0.0100    0.0000
   200        0.0030             nan     0.0100    0.0000

- Fold02: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold02: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0431             nan     0.0100    0.0007
     2        0.0425             nan     0.0100    0.0006
     3        0.0418             nan     0.0100    0.0006
     4        0.0412             nan     0.0100    0.0002
     5        0.0407             nan     0.0100    0.0004
     6        0.0401             nan     0.0100    0.0003
     7        0.0396             nan     0.0100    0.0003
     8        0.0392             nan     0.0100    0.0001
     9        0.0386             nan     0.0100    0.0006
    10        0.0379             nan     0.0100    0.0005
    20        0.0331             nan     0.0100    0.0003
    40        0.0253             nan     0.0100    0.0003
    60        0.0198             nan     0.0100    0.0003
    80        0.0155             nan     0.0100    0.0002
   100        0.0124             nan     0.0100    0.0002
   120        0.0098             nan     0.0100    0.0001
   140        0.0079             nan     0.0100    0.0000
   160        0.0064             nan     0.0100    0.0000
   180        0.0053             nan     0.0100    0.0001
   200        0.0044             nan     0.0100    0.0000

- Fold02: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold02: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0432             nan     0.0100    0.0003
     2        0.0431             nan     0.0100   -0.0002
     3        0.0423             nan     0.0100    0.0005
     4        0.0417             nan     0.0100    0.0006
     5        0.0412             nan     0.0100    0.0004
     6        0.0406             nan     0.0100    0.0006
     7        0.0403             nan     0.0100    0.0002
     8        0.0400             nan     0.0100    0.0003
     9        0.0395             nan     0.0100    0.0004
    10        0.0389             nan     0.0100    0.0004
    20        0.0345             nan     0.0100    0.0003
    40        0.0277             nan     0.0100    0.0003
    60        0.0227             nan     0.0100   -0.0001
    80        0.0186             nan     0.0100    0.0000
   100        0.0159             nan     0.0100   -0.0000
   120        0.0136             nan     0.0100   -0.0001
   140        0.0118             nan     0.0100   -0.0000
   160        0.0100             nan     0.0100    0.0000
   180        0.0088             nan     0.0100   -0.0000
   200        0.0079             nan     0.0100    0.0000

- Fold02: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold02: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0412             nan     0.0500    0.0021
     2        0.0383             nan     0.0500    0.0024
     3        0.0352             nan     0.0500    0.0026
     4        0.0324             nan     0.0500    0.0023
     5        0.0312             nan     0.0500    0.0002
     6        0.0297             nan     0.0500    0.0014
     7        0.0281             nan     0.0500    0.0011
     8        0.0264             nan     0.0500    0.0010
     9        0.0260             nan     0.0500   -0.0006
    10        0.0244             nan     0.0500    0.0017
    20        0.0134             nan     0.0500    0.0003
    40        0.0063             nan     0.0500   -0.0000
    60        0.0030             nan     0.0500   -0.0001
    80        0.0017             nan     0.0500    0.0000
   100        0.0010             nan     0.0500   -0.0000
   120        0.0005             nan     0.0500   -0.0000
   140        0.0003             nan     0.0500    0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold02: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold02: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0425             nan     0.0500   -0.0004
     2        0.0402             nan     0.0500    0.0023
     3        0.0374             nan     0.0500    0.0021
     4        0.0352             nan     0.0500    0.0016
     5        0.0342             nan     0.0500    0.0005
     6        0.0323             nan     0.0500    0.0016
     7        0.0302             nan     0.0500    0.0020
     8        0.0283             nan     0.0500    0.0015
     9        0.0270             nan     0.0500    0.0011
    10        0.0253             nan     0.0500    0.0010
    20        0.0147             nan     0.0500    0.0003
    40        0.0059             nan     0.0500    0.0002
    60        0.0029             nan     0.0500    0.0001
    80        0.0019             nan     0.0500   -0.0000
   100        0.0013             nan     0.0500   -0.0000
   120        0.0008             nan     0.0500    0.0000
   140        0.0005             nan     0.0500    0.0000
   160        0.0004             nan     0.0500   -0.0000
   180        0.0002             nan     0.0500    0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold02: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold02: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0416             nan     0.0500    0.0020
     2        0.0389             nan     0.0500    0.0023
     3        0.0363             nan     0.0500    0.0027
     4        0.0344             nan     0.0500    0.0018
     5        0.0336             nan     0.0500    0.0002
     6        0.0320             nan     0.0500    0.0020
     7        0.0305             nan     0.0500    0.0009
     8        0.0296             nan     0.0500   -0.0003
     9        0.0278             nan     0.0500    0.0003
    10        0.0265             nan     0.0500    0.0001
    20        0.0160             nan     0.0500    0.0004
    40        0.0077             nan     0.0500    0.0001
    60        0.0043             nan     0.0500    0.0000
    80        0.0029             nan     0.0500    0.0000
   100        0.0019             nan     0.0500   -0.0000
   120        0.0013             nan     0.0500   -0.0000
   140        0.0009             nan     0.0500   -0.0000
   160        0.0007             nan     0.0500    0.0000
   180        0.0005             nan     0.0500   -0.0000
   200        0.0004             nan     0.0500   -0.0000

- Fold02: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold02: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0420             nan     0.0500    0.0004
     2        0.0387             nan     0.0500    0.0022
     3        0.0361             nan     0.0500    0.0023
     4        0.0329             nan     0.0500    0.0032
     5        0.0304             nan     0.0500    0.0023
     6        0.0288             nan     0.0500    0.0011
     7        0.0264             nan     0.0500    0.0014
     8        0.0239             nan     0.0500    0.0025
     9        0.0224             nan     0.0500    0.0012
    10        0.0209             nan     0.0500    0.0015
    20        0.0119             nan     0.0500    0.0007
    40        0.0041             nan     0.0500    0.0003
    60        0.0016             nan     0.0500   -0.0000
    80        0.0006             nan     0.0500    0.0000
   100        0.0003             nan     0.0500   -0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0001             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold02: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold02: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0399             nan     0.0500    0.0030
     2        0.0371             nan     0.0500    0.0029
     3        0.0349             nan     0.0500    0.0019
     4        0.0325             nan     0.0500    0.0024
     5        0.0295             nan     0.0500    0.0023
     6        0.0275             nan     0.0500    0.0020
     7        0.0262             nan     0.0500    0.0000
     8        0.0248             nan     0.0500    0.0012
     9        0.0228             nan     0.0500    0.0017
    10        0.0215             nan     0.0500    0.0014
    20        0.0122             nan     0.0500    0.0001
    40        0.0045             nan     0.0500    0.0002
    60        0.0024             nan     0.0500    0.0000
    80        0.0013             nan     0.0500    0.0000
   100        0.0007             nan     0.0500    0.0000
   120        0.0004             nan     0.0500   -0.0000
   140        0.0003             nan     0.0500    0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold02: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold02: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0432             nan     0.0500   -0.0008
     2        0.0423             nan     0.0500   -0.0001
     3        0.0394             nan     0.0500    0.0027
     4        0.0373             nan     0.0500    0.0016
     5        0.0358             nan     0.0500    0.0005
     6        0.0342             nan     0.0500    0.0007
     7        0.0325             nan     0.0500    0.0013
     8        0.0306             nan     0.0500    0.0019
     9        0.0284             nan     0.0500    0.0018
    10        0.0265             nan     0.0500    0.0014
    20        0.0166             nan     0.0500    0.0008
    40        0.0087             nan     0.0500    0.0002
    60        0.0060             nan     0.0500   -0.0000
    80        0.0039             nan     0.0500    0.0001
   100        0.0026             nan     0.0500    0.0000
   120        0.0017             nan     0.0500    0.0000
   140        0.0012             nan     0.0500    0.0000
   160        0.0009             nan     0.0500   -0.0000
   180        0.0007             nan     0.0500    0.0000
   200        0.0005             nan     0.0500    0.0000

- Fold02: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold02: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0419             nan     0.0500    0.0014
     2        0.0395             nan     0.0500    0.0016
     3        0.0366             nan     0.0500    0.0018
     4        0.0330             nan     0.0500    0.0021
     5        0.0307             nan     0.0500    0.0018
     6        0.0281             nan     0.0500    0.0023
     7        0.0260             nan     0.0500    0.0019
     8        0.0248             nan     0.0500    0.0008
     9        0.0224             nan     0.0500    0.0021
    10        0.0207             nan     0.0500    0.0016
    20        0.0105             nan     0.0500    0.0006
    40        0.0030             nan     0.0500    0.0000
    60        0.0014             nan     0.0500   -0.0000
    80        0.0006             nan     0.0500   -0.0000
   100        0.0002             nan     0.0500   -0.0000
   120        0.0001             nan     0.0500    0.0000
   140        0.0001             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold02: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold02: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0414             nan     0.0500    0.0010
     2        0.0383             nan     0.0500    0.0014
     3        0.0365             nan     0.0500    0.0009
     4        0.0335             nan     0.0500    0.0028
     5        0.0326             nan     0.0500   -0.0004
     6        0.0301             nan     0.0500    0.0014
     7        0.0288             nan     0.0500    0.0007
     8        0.0272             nan     0.0500    0.0014
     9        0.0245             nan     0.0500    0.0015
    10        0.0223             nan     0.0500    0.0016
    20        0.0129             nan     0.0500   -0.0000
    40        0.0050             nan     0.0500    0.0002
    60        0.0019             nan     0.0500    0.0000
    80        0.0009             nan     0.0500    0.0000
   100        0.0005             nan     0.0500   -0.0000
   120        0.0003             nan     0.0500   -0.0000
   140        0.0002             nan     0.0500   -0.0000
   160        0.0001             nan     0.0500    0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold02: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold02: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0422             nan     0.0500    0.0006
     2        0.0401             nan     0.0500    0.0014
     3        0.0387             nan     0.0500    0.0006
     4        0.0358             nan     0.0500    0.0020
     5        0.0338             nan     0.0500    0.0013
     6        0.0309             nan     0.0500    0.0014
     7        0.0289             nan     0.0500    0.0016
     8        0.0273             nan     0.0500    0.0011
     9        0.0258             nan     0.0500    0.0014
    10        0.0244             nan     0.0500    0.0005
    20        0.0153             nan     0.0500    0.0006
    40        0.0081             nan     0.0500    0.0002
    60        0.0048             nan     0.0500    0.0001
    80        0.0030             nan     0.0500    0.0000
   100        0.0019             nan     0.0500   -0.0000
   120        0.0012             nan     0.0500   -0.0000
   140        0.0009             nan     0.0500   -0.0000
   160        0.0006             nan     0.0500   -0.0000
   180        0.0004             nan     0.0500   -0.0000
   200        0.0003             nan     0.0500   -0.0000

- Fold02: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold02: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0377             nan     0.1000    0.0058
     2        0.0346             nan     0.1000    0.0010
     3        0.0316             nan     0.1000    0.0024
     4        0.0273             nan     0.1000    0.0038
     5        0.0247             nan     0.1000    0.0024
     6        0.0218             nan     0.1000    0.0012
     7        0.0200             nan     0.1000    0.0013
     8        0.0174             nan     0.1000    0.0017
     9        0.0160             nan     0.1000    0.0007
    10        0.0141             nan     0.1000    0.0019
    20        0.0059             nan     0.1000    0.0000
    40        0.0018             nan     0.1000   -0.0001
    60        0.0006             nan     0.1000   -0.0000
    80        0.0002             nan     0.1000    0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold02: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold02: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0388             nan     0.1000    0.0048
     2        0.0344             nan     0.1000    0.0041
     3        0.0311             nan     0.1000    0.0031
     4        0.0301             nan     0.1000   -0.0014
     5        0.0272             nan     0.1000    0.0028
     6        0.0247             nan     0.1000    0.0029
     7        0.0219             nan     0.1000    0.0029
     8        0.0198             nan     0.1000   -0.0005
     9        0.0183             nan     0.1000    0.0012
    10        0.0173             nan     0.1000   -0.0004
    20        0.0080             nan     0.1000    0.0000
    40        0.0030             nan     0.1000   -0.0001
    60        0.0011             nan     0.1000    0.0000
    80        0.0005             nan     0.1000   -0.0001
   100        0.0003             nan     0.1000   -0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000    0.0000
   160        0.0000             nan     0.1000    0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold02: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold02: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0382             nan     0.1000    0.0057
     2        0.0347             nan     0.1000    0.0028
     3        0.0304             nan     0.1000    0.0041
     4        0.0267             nan     0.1000    0.0029
     5        0.0244             nan     0.1000    0.0015
     6        0.0229             nan     0.1000    0.0021
     7        0.0208             nan     0.1000    0.0016
     8        0.0188             nan     0.1000    0.0018
     9        0.0167             nan     0.1000    0.0013
    10        0.0148             nan     0.1000    0.0010
    20        0.0076             nan     0.1000    0.0003
    40        0.0037             nan     0.1000    0.0002
    60        0.0018             nan     0.1000   -0.0000
    80        0.0010             nan     0.1000   -0.0001
   100        0.0005             nan     0.1000   -0.0000
   120        0.0003             nan     0.1000    0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold02: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold02: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0357             nan     0.1000    0.0079
     2        0.0306             nan     0.1000    0.0040
     3        0.0264             nan     0.1000    0.0030
     4        0.0224             nan     0.1000    0.0017
     5        0.0202             nan     0.1000    0.0020
     6        0.0168             nan     0.1000    0.0027
     7        0.0153             nan     0.1000    0.0005
     8        0.0127             nan     0.1000    0.0030
     9        0.0115             nan     0.1000    0.0008
    10        0.0100             nan     0.1000    0.0006
    20        0.0039             nan     0.1000    0.0005
    40        0.0008             nan     0.1000    0.0000
    60        0.0002             nan     0.1000    0.0000
    80        0.0000             nan     0.1000    0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold02: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold02: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0379             nan     0.1000    0.0054
     2        0.0334             nan     0.1000    0.0036
     3        0.0301             nan     0.1000    0.0007
     4        0.0254             nan     0.1000    0.0046
     5        0.0220             nan     0.1000    0.0017
     6        0.0185             nan     0.1000    0.0025
     7        0.0165             nan     0.1000    0.0018
     8        0.0148             nan     0.1000    0.0006
     9        0.0122             nan     0.1000    0.0010
    10        0.0106             nan     0.1000    0.0012
    20        0.0039             nan     0.1000   -0.0003
    40        0.0010             nan     0.1000    0.0000
    60        0.0003             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000    0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold02: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold02: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0387             nan     0.1000    0.0057
     2        0.0346             nan     0.1000    0.0030
     3        0.0338             nan     0.1000   -0.0018
     4        0.0301             nan     0.1000    0.0040
     5        0.0266             nan     0.1000    0.0035
     6        0.0249             nan     0.1000    0.0014
     7        0.0220             nan     0.1000    0.0024
     8        0.0206             nan     0.1000    0.0005
     9        0.0186             nan     0.1000    0.0013
    10        0.0173             nan     0.1000    0.0011
    20        0.0096             nan     0.1000   -0.0001
    40        0.0035             nan     0.1000   -0.0001
    60        0.0018             nan     0.1000    0.0001
    80        0.0010             nan     0.1000   -0.0000
   100        0.0007             nan     0.1000   -0.0000
   120        0.0004             nan     0.1000    0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000    0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold02: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold02: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0426             nan     0.1000   -0.0012
     2        0.0361             nan     0.1000    0.0021
     3        0.0313             nan     0.1000    0.0029
     4        0.0278             nan     0.1000    0.0031
     5        0.0247             nan     0.1000    0.0025
     6        0.0218             nan     0.1000    0.0027
     7        0.0193             nan     0.1000    0.0020
     8        0.0175             nan     0.1000    0.0024
     9        0.0159             nan     0.1000    0.0011
    10        0.0143             nan     0.1000    0.0012
    20        0.0039             nan     0.1000    0.0005
    40        0.0006             nan     0.1000   -0.0000
    60        0.0001             nan     0.1000   -0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000    0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000    0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold02: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold02: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0362             nan     0.1000    0.0045
     2        0.0317             nan     0.1000    0.0042
     3        0.0279             nan     0.1000    0.0019
     4        0.0248             nan     0.1000    0.0023
     5        0.0216             nan     0.1000    0.0027
     6        0.0193             nan     0.1000    0.0017
     7        0.0172             nan     0.1000    0.0005
     8        0.0161             nan     0.1000    0.0007
     9        0.0149             nan     0.1000    0.0010
    10        0.0133             nan     0.1000    0.0015
    20        0.0044             nan     0.1000    0.0001
    40        0.0012             nan     0.1000   -0.0000
    60        0.0004             nan     0.1000   -0.0000
    80        0.0002             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000    0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold02: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold02: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0383             nan     0.1000    0.0048
     2        0.0339             nan     0.1000    0.0037
     3        0.0311             nan     0.1000    0.0003
     4        0.0279             nan     0.1000    0.0022
     5        0.0245             nan     0.1000    0.0030
     6        0.0217             nan     0.1000    0.0016
     7        0.0200             nan     0.1000    0.0013
     8        0.0185             nan     0.1000    0.0009
     9        0.0164             nan     0.1000    0.0009
    10        0.0140             nan     0.1000    0.0008
    20        0.0077             nan     0.1000   -0.0002
    40        0.0034             nan     0.1000   -0.0001
    60        0.0015             nan     0.1000   -0.0000
    80        0.0008             nan     0.1000   -0.0000
   100        0.0005             nan     0.1000   -0.0000
   120        0.0004             nan     0.1000    0.0000
   140        0.0003             nan     0.1000   -0.0000
   160        0.0002             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold02: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold03: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0368             nan     0.0100    0.0005
     2        0.0363             nan     0.0100    0.0005
     3        0.0358             nan     0.0100    0.0004
     4        0.0355             nan     0.0100    0.0002
     5        0.0351             nan     0.0100    0.0003
     6        0.0348             nan     0.0100    0.0001
     7        0.0344             nan     0.0100    0.0001
     8        0.0340             nan     0.0100    0.0004
     9        0.0334             nan     0.0100    0.0005
    10        0.0330             nan     0.0100    0.0002
    20        0.0293             nan     0.0100    0.0003
    40        0.0236             nan     0.0100    0.0002
    60        0.0193             nan     0.0100    0.0002
    80        0.0155             nan     0.0100    0.0003
   100        0.0130             nan     0.0100    0.0001
   120        0.0109             nan     0.0100    0.0001
   140        0.0090             nan     0.0100    0.0000
   160        0.0077             nan     0.0100   -0.0000
   180        0.0065             nan     0.0100    0.0000
   200        0.0056             nan     0.0100    0.0000

- Fold03: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold03: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0369             nan     0.0100    0.0005
     2        0.0364             nan     0.0100    0.0004
     3        0.0361             nan     0.0100    0.0002
     4        0.0355             nan     0.0100    0.0004
     5        0.0351             nan     0.0100    0.0004
     6        0.0346             nan     0.0100    0.0003
     7        0.0341             nan     0.0100    0.0004
     8        0.0338             nan     0.0100    0.0002
     9        0.0333             nan     0.0100    0.0004
    10        0.0330             nan     0.0100    0.0002
    20        0.0292             nan     0.0100    0.0004
    40        0.0235             nan     0.0100    0.0003
    60        0.0192             nan     0.0100    0.0001
    80        0.0159             nan     0.0100   -0.0000
   100        0.0132             nan     0.0100    0.0000
   120        0.0111             nan     0.0100    0.0000
   140        0.0092             nan     0.0100    0.0001
   160        0.0079             nan     0.0100    0.0000
   180        0.0069             nan     0.0100    0.0000
   200        0.0059             nan     0.0100    0.0000

- Fold03: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold03: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0369             nan     0.0100    0.0004
     2        0.0364             nan     0.0100    0.0005
     3        0.0358             nan     0.0100    0.0005
     4        0.0355             nan     0.0100    0.0003
     5        0.0353             nan     0.0100   -0.0000
     6        0.0350             nan     0.0100    0.0002
     7        0.0346             nan     0.0100    0.0004
     8        0.0341             nan     0.0100    0.0005
     9        0.0336             nan     0.0100    0.0004
    10        0.0331             nan     0.0100    0.0004
    20        0.0293             nan     0.0100    0.0004
    40        0.0234             nan     0.0100    0.0002
    60        0.0188             nan     0.0100    0.0002
    80        0.0153             nan     0.0100    0.0000
   100        0.0129             nan     0.0100    0.0001
   120        0.0111             nan     0.0100    0.0000
   140        0.0097             nan     0.0100    0.0001
   160        0.0085             nan     0.0100    0.0000
   180        0.0075             nan     0.0100    0.0000
   200        0.0068             nan     0.0100    0.0000

- Fold03: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold03: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0368             nan     0.0100    0.0002
     2        0.0362             nan     0.0100    0.0007
     3        0.0355             nan     0.0100    0.0005
     4        0.0351             nan     0.0100    0.0002
     5        0.0345             nan     0.0100    0.0004
     6        0.0341             nan     0.0100    0.0001
     7        0.0337             nan     0.0100    0.0002
     8        0.0334             nan     0.0100    0.0000
     9        0.0330             nan     0.0100    0.0003
    10        0.0324             nan     0.0100    0.0003
    20        0.0281             nan     0.0100    0.0004
    40        0.0216             nan     0.0100    0.0002
    60        0.0167             nan     0.0100    0.0000
    80        0.0132             nan     0.0100    0.0001
   100        0.0104             nan     0.0100    0.0001
   120        0.0083             nan     0.0100    0.0000
   140        0.0067             nan     0.0100    0.0000
   160        0.0054             nan     0.0100    0.0000
   180        0.0044             nan     0.0100   -0.0000
   200        0.0037             nan     0.0100    0.0000

- Fold03: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold03: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0367             nan     0.0100    0.0006
     2        0.0361             nan     0.0100    0.0006
     3        0.0355             nan     0.0100    0.0002
     4        0.0350             nan     0.0100    0.0002
     5        0.0346             nan     0.0100    0.0004
     6        0.0343             nan     0.0100    0.0002
     7        0.0339             nan     0.0100    0.0002
     8        0.0335             nan     0.0100    0.0004
     9        0.0330             nan     0.0100    0.0002
    10        0.0326             nan     0.0100    0.0004
    20        0.0285             nan     0.0100    0.0003
    40        0.0220             nan     0.0100    0.0001
    60        0.0173             nan     0.0100    0.0003
    80        0.0134             nan     0.0100   -0.0000
   100        0.0108             nan     0.0100    0.0000
   120        0.0088             nan     0.0100    0.0000
   140        0.0071             nan     0.0100    0.0001
   160        0.0057             nan     0.0100    0.0000
   180        0.0048             nan     0.0100    0.0000
   200        0.0040             nan     0.0100    0.0000

- Fold03: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold03: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0369             nan     0.0100    0.0004
     2        0.0365             nan     0.0100    0.0002
     3        0.0360             nan     0.0100    0.0005
     4        0.0356             nan     0.0100    0.0004
     5        0.0350             nan     0.0100    0.0005
     6        0.0346             nan     0.0100    0.0004
     7        0.0342             nan     0.0100    0.0005
     8        0.0338             nan     0.0100    0.0003
     9        0.0335             nan     0.0100    0.0004
    10        0.0330             nan     0.0100    0.0003
    20        0.0291             nan     0.0100    0.0002
    40        0.0231             nan     0.0100    0.0001
    60        0.0189             nan     0.0100    0.0001
    80        0.0160             nan     0.0100    0.0001
   100        0.0139             nan     0.0100    0.0000
   120        0.0119             nan     0.0100    0.0001
   140        0.0102             nan     0.0100    0.0000
   160        0.0090             nan     0.0100    0.0000
   180        0.0079             nan     0.0100    0.0000
   200        0.0072             nan     0.0100   -0.0000

- Fold03: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold03: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0367             nan     0.0100    0.0007
     2        0.0362             nan     0.0100    0.0003
     3        0.0356             nan     0.0100    0.0004
     4        0.0350             nan     0.0100    0.0006
     5        0.0348             nan     0.0100   -0.0000
     6        0.0343             nan     0.0100    0.0004
     7        0.0340             nan     0.0100    0.0001
     8        0.0336             nan     0.0100    0.0003
     9        0.0332             nan     0.0100    0.0003
    10        0.0326             nan     0.0100    0.0004
    20        0.0285             nan     0.0100    0.0003
    40        0.0216             nan     0.0100    0.0002
    60        0.0162             nan     0.0100    0.0001
    80        0.0124             nan     0.0100    0.0001
   100        0.0096             nan     0.0100   -0.0000
   120        0.0072             nan     0.0100    0.0001
   140        0.0057             nan     0.0100    0.0000
   160        0.0047             nan     0.0100   -0.0001
   180        0.0037             nan     0.0100    0.0001
   200        0.0029             nan     0.0100   -0.0000

- Fold03: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold03: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0369             nan     0.0100    0.0002
     2        0.0362             nan     0.0100    0.0006
     3        0.0357             nan     0.0100    0.0004
     4        0.0352             nan     0.0100    0.0005
     5        0.0348             nan     0.0100    0.0003
     6        0.0343             nan     0.0100    0.0004
     7        0.0338             nan     0.0100    0.0004
     8        0.0333             nan     0.0100    0.0003
     9        0.0328             nan     0.0100    0.0001
    10        0.0323             nan     0.0100    0.0004
    20        0.0283             nan     0.0100    0.0003
    40        0.0217             nan     0.0100    0.0002
    60        0.0170             nan     0.0100    0.0002
    80        0.0133             nan     0.0100    0.0002
   100        0.0105             nan     0.0100    0.0001
   120        0.0087             nan     0.0100    0.0001
   140        0.0070             nan     0.0100    0.0000
   160        0.0058             nan     0.0100   -0.0000
   180        0.0051             nan     0.0100    0.0000
   200        0.0042             nan     0.0100    0.0000

- Fold03: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold03: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0371             nan     0.0100   -0.0000
     2        0.0370             nan     0.0100   -0.0001
     3        0.0365             nan     0.0100    0.0005
     4        0.0361             nan     0.0100    0.0004
     5        0.0357             nan     0.0100    0.0004
     6        0.0353             nan     0.0100    0.0004
     7        0.0348             nan     0.0100    0.0005
     8        0.0343             nan     0.0100    0.0004
     9        0.0342             nan     0.0100   -0.0002
    10        0.0338             nan     0.0100    0.0003
    20        0.0298             nan     0.0100    0.0002
    40        0.0237             nan     0.0100    0.0003
    60        0.0193             nan     0.0100    0.0001
    80        0.0160             nan     0.0100    0.0000
   100        0.0137             nan     0.0100    0.0001
   120        0.0118             nan     0.0100   -0.0000
   140        0.0103             nan     0.0100    0.0000
   160        0.0092             nan     0.0100   -0.0001
   180        0.0082             nan     0.0100    0.0000
   200        0.0072             nan     0.0100    0.0000

- Fold03: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold03: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0352             nan     0.0500    0.0020
     2        0.0322             nan     0.0500    0.0024
     3        0.0304             nan     0.0500    0.0016
     4        0.0287             nan     0.0500    0.0006
     5        0.0268             nan     0.0500    0.0013
     6        0.0256             nan     0.0500    0.0008
     7        0.0241             nan     0.0500    0.0017
     8        0.0228             nan     0.0500    0.0008
     9        0.0214             nan     0.0500    0.0010
    10        0.0205             nan     0.0500    0.0008
    20        0.0124             nan     0.0500    0.0001
    40        0.0051             nan     0.0500    0.0001
    60        0.0024             nan     0.0500    0.0000
    80        0.0015             nan     0.0500   -0.0001
   100        0.0009             nan     0.0500   -0.0000
   120        0.0005             nan     0.0500    0.0000
   140        0.0003             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500    0.0000

- Fold03: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold03: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0352             nan     0.0500    0.0025
     2        0.0329             nan     0.0500    0.0017
     3        0.0308             nan     0.0500    0.0016
     4        0.0294             nan     0.0500    0.0010
     5        0.0276             nan     0.0500    0.0006
     6        0.0261             nan     0.0500    0.0006
     7        0.0249             nan     0.0500    0.0007
     8        0.0236             nan     0.0500    0.0005
     9        0.0220             nan     0.0500    0.0013
    10        0.0204             nan     0.0500    0.0010
    20        0.0128             nan     0.0500    0.0006
    40        0.0057             nan     0.0500   -0.0001
    60        0.0029             nan     0.0500   -0.0000
    80        0.0017             nan     0.0500   -0.0001
   100        0.0011             nan     0.0500   -0.0000
   120        0.0007             nan     0.0500    0.0000
   140        0.0004             nan     0.0500    0.0000
   160        0.0003             nan     0.0500   -0.0000
   180        0.0002             nan     0.0500    0.0000
   200        0.0002             nan     0.0500   -0.0000

- Fold03: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold03: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0361             nan     0.0500    0.0011
     2        0.0351             nan     0.0500    0.0001
     3        0.0325             nan     0.0500    0.0023
     4        0.0308             nan     0.0500    0.0018
     5        0.0289             nan     0.0500    0.0021
     6        0.0269             nan     0.0500    0.0017
     7        0.0257             nan     0.0500    0.0008
     8        0.0242             nan     0.0500    0.0014
     9        0.0232             nan     0.0500    0.0008
    10        0.0216             nan     0.0500    0.0007
    20        0.0139             nan     0.0500    0.0007
    40        0.0075             nan     0.0500   -0.0001
    60        0.0053             nan     0.0500   -0.0000
    80        0.0038             nan     0.0500    0.0000
   100        0.0029             nan     0.0500   -0.0000
   120        0.0022             nan     0.0500    0.0000
   140        0.0018             nan     0.0500    0.0000
   160        0.0014             nan     0.0500   -0.0000
   180        0.0011             nan     0.0500   -0.0000
   200        0.0008             nan     0.0500    0.0000

- Fold03: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold03: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0337             nan     0.0500    0.0040
     2        0.0310             nan     0.0500    0.0026
     3        0.0298             nan     0.0500    0.0013
     4        0.0272             nan     0.0500    0.0028
     5        0.0256             nan     0.0500    0.0002
     6        0.0235             nan     0.0500    0.0020
     7        0.0223             nan     0.0500    0.0009
     8        0.0206             nan     0.0500    0.0014
     9        0.0199             nan     0.0500    0.0002
    10        0.0188             nan     0.0500    0.0002
    20        0.0103             nan     0.0500    0.0006
    40        0.0035             nan     0.0500   -0.0000
    60        0.0015             nan     0.0500   -0.0000
    80        0.0006             nan     0.0500   -0.0000
   100        0.0003             nan     0.0500    0.0000
   120        0.0002             nan     0.0500   -0.0000
   140        0.0001             nan     0.0500    0.0000
   160        0.0000             nan     0.0500    0.0000
   180        0.0000             nan     0.0500    0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold03: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold03: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0354             nan     0.0500    0.0018
     2        0.0333             nan     0.0500    0.0020
     3        0.0308             nan     0.0500    0.0011
     4        0.0277             nan     0.0500    0.0025
     5        0.0261             nan     0.0500    0.0014
     6        0.0245             nan     0.0500    0.0015
     7        0.0230             nan     0.0500    0.0017
     8        0.0217             nan     0.0500    0.0010
     9        0.0201             nan     0.0500    0.0015
    10        0.0187             nan     0.0500    0.0005
    20        0.0103             nan     0.0500    0.0005
    40        0.0035             nan     0.0500    0.0001
    60        0.0018             nan     0.0500   -0.0000
    80        0.0009             nan     0.0500    0.0000
   100        0.0005             nan     0.0500    0.0000
   120        0.0003             nan     0.0500   -0.0000
   140        0.0002             nan     0.0500    0.0000
   160        0.0001             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500    0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold03: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold03: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0350             nan     0.0500    0.0021
     2        0.0326             nan     0.0500    0.0020
     3        0.0308             nan     0.0500    0.0018
     4        0.0296             nan     0.0500    0.0007
     5        0.0285             nan     0.0500    0.0007
     6        0.0275             nan     0.0500    0.0003
     7        0.0265             nan     0.0500    0.0010
     8        0.0254             nan     0.0500    0.0008
     9        0.0236             nan     0.0500    0.0013
    10        0.0225             nan     0.0500    0.0009
    20        0.0153             nan     0.0500    0.0007
    40        0.0083             nan     0.0500    0.0002
    60        0.0059             nan     0.0500   -0.0001
    80        0.0040             nan     0.0500    0.0001
   100        0.0030             nan     0.0500   -0.0001
   120        0.0023             nan     0.0500   -0.0000
   140        0.0017             nan     0.0500   -0.0000
   160        0.0012             nan     0.0500   -0.0000
   180        0.0009             nan     0.0500   -0.0000
   200        0.0007             nan     0.0500   -0.0000

- Fold03: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold03: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0337             nan     0.0500    0.0033
     2        0.0308             nan     0.0500    0.0029
     3        0.0280             nan     0.0500    0.0025
     4        0.0260             nan     0.0500    0.0007
     5        0.0235             nan     0.0500    0.0019
     6        0.0220             nan     0.0500    0.0006
     7        0.0205             nan     0.0500    0.0014
     8        0.0195             nan     0.0500    0.0003
     9        0.0181             nan     0.0500    0.0012
    10        0.0168             nan     0.0500    0.0011
    20        0.0081             nan     0.0500    0.0007
    40        0.0022             nan     0.0500    0.0001
    60        0.0009             nan     0.0500    0.0000
    80        0.0003             nan     0.0500    0.0000
   100        0.0002             nan     0.0500   -0.0000
   120        0.0001             nan     0.0500    0.0000
   140        0.0000             nan     0.0500    0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold03: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold03: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0341             nan     0.0500    0.0027
     2        0.0322             nan     0.0500    0.0017
     3        0.0296             nan     0.0500    0.0010
     4        0.0279             nan     0.0500    0.0017
     5        0.0264             nan     0.0500    0.0013
     6        0.0239             nan     0.0500    0.0010
     7        0.0227             nan     0.0500    0.0013
     8        0.0211             nan     0.0500    0.0002
     9        0.0196             nan     0.0500    0.0013
    10        0.0186             nan     0.0500    0.0000
    20        0.0099             nan     0.0500    0.0005
    40        0.0036             nan     0.0500    0.0002
    60        0.0017             nan     0.0500    0.0000
    80        0.0009             nan     0.0500   -0.0000
   100        0.0005             nan     0.0500    0.0000
   120        0.0003             nan     0.0500   -0.0000
   140        0.0002             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500    0.0000

- Fold03: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold03: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0352             nan     0.0500    0.0007
     2        0.0332             nan     0.0500    0.0023
     3        0.0313             nan     0.0500    0.0018
     4        0.0294             nan     0.0500    0.0017
     5        0.0276             nan     0.0500    0.0014
     6        0.0268             nan     0.0500   -0.0002
     7        0.0256             nan     0.0500    0.0011
     8        0.0242             nan     0.0500    0.0014
     9        0.0230             nan     0.0500    0.0007
    10        0.0216             nan     0.0500    0.0011
    20        0.0144             nan     0.0500    0.0007
    40        0.0087             nan     0.0500   -0.0002
    60        0.0048             nan     0.0500    0.0001
    80        0.0036             nan     0.0500   -0.0000
   100        0.0026             nan     0.0500   -0.0001
   120        0.0018             nan     0.0500   -0.0000
   140        0.0014             nan     0.0500   -0.0000
   160        0.0011             nan     0.0500   -0.0000
   180        0.0008             nan     0.0500    0.0000
   200        0.0006             nan     0.0500   -0.0000

- Fold03: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold03: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0335             nan     0.1000    0.0044
     2        0.0305             nan     0.1000    0.0028
     3        0.0269             nan     0.1000    0.0029
     4        0.0246             nan     0.1000    0.0022
     5        0.0222             nan     0.1000    0.0013
     6        0.0192             nan     0.1000    0.0024
     7        0.0172             nan     0.1000    0.0020
     8        0.0156             nan     0.1000    0.0002
     9        0.0141             nan     0.1000    0.0006
    10        0.0125             nan     0.1000    0.0012
    20        0.0058             nan     0.1000    0.0002
    40        0.0018             nan     0.1000    0.0001
    60        0.0008             nan     0.1000   -0.0000
    80        0.0003             nan     0.1000   -0.0000
   100        0.0002             nan     0.1000   -0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold03: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold03: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0322             nan     0.1000    0.0038
     2        0.0279             nan     0.1000    0.0043
     3        0.0243             nan     0.1000    0.0031
     4        0.0217             nan     0.1000    0.0026
     5        0.0195             nan     0.1000    0.0021
     6        0.0174             nan     0.1000    0.0019
     7        0.0160             nan     0.1000    0.0014
     8        0.0146             nan     0.1000    0.0009
     9        0.0128             nan     0.1000    0.0005
    10        0.0114             nan     0.1000    0.0009
    20        0.0056             nan     0.1000    0.0001
    40        0.0020             nan     0.1000   -0.0001
    60        0.0008             nan     0.1000   -0.0001
    80        0.0004             nan     0.1000   -0.0000
   100        0.0002             nan     0.1000    0.0000
   120        0.0001             nan     0.1000    0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold03: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold03: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0318             nan     0.1000    0.0046
     2        0.0289             nan     0.1000    0.0027
     3        0.0267             nan     0.1000    0.0017
     4        0.0239             nan     0.1000    0.0026
     5        0.0215             nan     0.1000    0.0002
     6        0.0191             nan     0.1000    0.0019
     7        0.0181             nan     0.1000    0.0003
     8        0.0171             nan     0.1000    0.0004
     9        0.0151             nan     0.1000    0.0011
    10        0.0148             nan     0.1000   -0.0003
    20        0.0082             nan     0.1000   -0.0005
    40        0.0040             nan     0.1000   -0.0001
    60        0.0025             nan     0.1000    0.0000
    80        0.0015             nan     0.1000    0.0001
   100        0.0010             nan     0.1000   -0.0001
   120        0.0006             nan     0.1000    0.0000
   140        0.0004             nan     0.1000   -0.0000
   160        0.0003             nan     0.1000    0.0000
   180        0.0002             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold03: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold03: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0324             nan     0.1000    0.0055
     2        0.0281             nan     0.1000    0.0037
     3        0.0229             nan     0.1000    0.0049
     4        0.0198             nan     0.1000    0.0025
     5        0.0176             nan     0.1000    0.0013
     6        0.0156             nan     0.1000    0.0021
     7        0.0139             nan     0.1000    0.0003
     8        0.0118             nan     0.1000    0.0011
     9        0.0102             nan     0.1000    0.0007
    10        0.0085             nan     0.1000    0.0010
    20        0.0025             nan     0.1000    0.0002
    40        0.0003             nan     0.1000   -0.0000
    60        0.0001             nan     0.1000   -0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000    0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold03: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold03: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0315             nan     0.1000    0.0054
     2        0.0301             nan     0.1000    0.0001
     3        0.0255             nan     0.1000    0.0031
     4        0.0218             nan     0.1000    0.0037
     5        0.0190             nan     0.1000    0.0020
     6        0.0175             nan     0.1000    0.0003
     7        0.0157             nan     0.1000    0.0013
     8        0.0133             nan     0.1000    0.0013
     9        0.0109             nan     0.1000    0.0010
    10        0.0101             nan     0.1000    0.0010
    20        0.0045             nan     0.1000    0.0000
    40        0.0009             nan     0.1000    0.0001
    60        0.0003             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000    0.0000
   140        0.0000             nan     0.1000    0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold03: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold03: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0318             nan     0.1000    0.0050
     2        0.0284             nan     0.1000    0.0034
     3        0.0252             nan     0.1000    0.0032
     4        0.0215             nan     0.1000    0.0024
     5        0.0197             nan     0.1000    0.0009
     6        0.0181             nan     0.1000    0.0004
     7        0.0168             nan     0.1000   -0.0004
     8        0.0159             nan     0.1000    0.0003
     9        0.0143             nan     0.1000    0.0007
    10        0.0124             nan     0.1000    0.0013
    20        0.0070             nan     0.1000   -0.0002
    40        0.0034             nan     0.1000    0.0001
    60        0.0018             nan     0.1000   -0.0000
    80        0.0011             nan     0.1000   -0.0000
   100        0.0006             nan     0.1000    0.0000
   120        0.0004             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0002             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000    0.0000

- Fold03: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold03: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0329             nan     0.1000    0.0029
     2        0.0280             nan     0.1000    0.0032
     3        0.0232             nan     0.1000    0.0034
     4        0.0203             nan     0.1000    0.0017
     5        0.0179             nan     0.1000    0.0006
     6        0.0152             nan     0.1000    0.0036
     7        0.0143             nan     0.1000   -0.0004
     8        0.0123             nan     0.1000    0.0010
     9        0.0101             nan     0.1000    0.0020
    10        0.0086             nan     0.1000    0.0011
    20        0.0031             nan     0.1000    0.0000
    40        0.0004             nan     0.1000   -0.0000
    60        0.0001             nan     0.1000   -0.0000
    80        0.0000             nan     0.1000    0.0000
   100        0.0000             nan     0.1000    0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold03: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold03: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0337             nan     0.1000    0.0019
     2        0.0288             nan     0.1000    0.0047
     3        0.0256             nan     0.1000    0.0027
     4        0.0223             nan     0.1000    0.0025
     5        0.0183             nan     0.1000    0.0029
     6        0.0173             nan     0.1000    0.0001
     7        0.0157             nan     0.1000    0.0016
     8        0.0139             nan     0.1000    0.0016
     9        0.0127             nan     0.1000    0.0005
    10        0.0109             nan     0.1000    0.0010
    20        0.0055             nan     0.1000    0.0000
    40        0.0013             nan     0.1000   -0.0000
    60        0.0005             nan     0.1000    0.0000
    80        0.0003             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000    0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold03: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold03: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0334             nan     0.1000    0.0042
     2        0.0305             nan     0.1000   -0.0012
     3        0.0263             nan     0.1000    0.0039
     4        0.0242             nan     0.1000    0.0017
     5        0.0222             nan     0.1000    0.0010
     6        0.0200             nan     0.1000    0.0023
     7        0.0185             nan     0.1000   -0.0001
     8        0.0167             nan     0.1000    0.0012
     9        0.0151             nan     0.1000    0.0011
    10        0.0140             nan     0.1000    0.0008
    20        0.0076             nan     0.1000    0.0003
    40        0.0033             nan     0.1000   -0.0000
    60        0.0017             nan     0.1000   -0.0001
    80        0.0010             nan     0.1000   -0.0000
   100        0.0005             nan     0.1000   -0.0000
   120        0.0003             nan     0.1000    0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000    0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold03: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold04: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0439             nan     0.0100    0.0001
     2        0.0435             nan     0.0100    0.0001
     3        0.0430             nan     0.0100    0.0002
     4        0.0424             nan     0.0100    0.0006
     5        0.0417             nan     0.0100    0.0006
     6        0.0413             nan     0.0100    0.0003
     7        0.0407             nan     0.0100    0.0004
     8        0.0401             nan     0.0100    0.0006
     9        0.0396             nan     0.0100    0.0002
    10        0.0393             nan     0.0100    0.0002
    20        0.0353             nan     0.0100    0.0002
    40        0.0279             nan     0.0100    0.0002
    60        0.0224             nan     0.0100    0.0003
    80        0.0180             nan     0.0100    0.0002
   100        0.0148             nan     0.0100    0.0001
   120        0.0121             nan     0.0100    0.0000
   140        0.0099             nan     0.0100    0.0000
   160        0.0083             nan     0.0100    0.0000
   180        0.0071             nan     0.0100    0.0000
   200        0.0060             nan     0.0100    0.0000

- Fold04: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold04: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0436             nan     0.0100    0.0006
     2        0.0430             nan     0.0100    0.0004
     3        0.0424             nan     0.0100    0.0005
     4        0.0418             nan     0.0100    0.0006
     5        0.0414             nan     0.0100    0.0005
     6        0.0410             nan     0.0100    0.0000
     7        0.0405             nan     0.0100    0.0003
     8        0.0400             nan     0.0100    0.0000
     9        0.0395             nan     0.0100    0.0005
    10        0.0390             nan     0.0100    0.0005
    20        0.0345             nan     0.0100    0.0002
    40        0.0274             nan     0.0100   -0.0000
    60        0.0217             nan     0.0100    0.0001
    80        0.0178             nan     0.0100    0.0000
   100        0.0143             nan     0.0100    0.0001
   120        0.0119             nan     0.0100    0.0001
   140        0.0099             nan     0.0100    0.0000
   160        0.0085             nan     0.0100   -0.0000
   180        0.0072             nan     0.0100    0.0000
   200        0.0060             nan     0.0100   -0.0000

- Fold04: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold04: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0438             nan     0.0100    0.0006
     2        0.0433             nan     0.0100    0.0005
     3        0.0428             nan     0.0100    0.0002
     4        0.0423             nan     0.0100    0.0006
     5        0.0420             nan     0.0100    0.0001
     6        0.0418             nan     0.0100    0.0002
     7        0.0414             nan     0.0100    0.0004
     8        0.0408             nan     0.0100    0.0005
     9        0.0403             nan     0.0100    0.0005
    10        0.0399             nan     0.0100    0.0004
    20        0.0356             nan     0.0100    0.0005
    40        0.0286             nan     0.0100    0.0004
    60        0.0227             nan     0.0100    0.0003
    80        0.0187             nan     0.0100   -0.0001
   100        0.0157             nan     0.0100    0.0001
   120        0.0134             nan     0.0100    0.0001
   140        0.0117             nan     0.0100   -0.0000
   160        0.0102             nan     0.0100    0.0000
   180        0.0091             nan     0.0100    0.0000
   200        0.0081             nan     0.0100    0.0000

- Fold04: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold04: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0440             nan     0.0100   -0.0001
     2        0.0434             nan     0.0100    0.0005
     3        0.0427             nan     0.0100    0.0006
     4        0.0420             nan     0.0100    0.0003
     5        0.0414             nan     0.0100    0.0005
     6        0.0409             nan     0.0100    0.0005
     7        0.0405             nan     0.0100    0.0001
     8        0.0399             nan     0.0100    0.0003
     9        0.0391             nan     0.0100    0.0006
    10        0.0384             nan     0.0100    0.0005
    20        0.0339             nan     0.0100    0.0003
    40        0.0255             nan     0.0100    0.0003
    60        0.0194             nan     0.0100    0.0002
    80        0.0149             nan     0.0100    0.0001
   100        0.0115             nan     0.0100    0.0001
   120        0.0092             nan     0.0100    0.0001
   140        0.0072             nan     0.0100    0.0000
   160        0.0058             nan     0.0100    0.0001
   180        0.0046             nan     0.0100    0.0000
   200        0.0037             nan     0.0100    0.0000

- Fold04: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold04: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0440             nan     0.0100    0.0003
     2        0.0433             nan     0.0100    0.0006
     3        0.0428             nan     0.0100    0.0005
     4        0.0421             nan     0.0100    0.0004
     5        0.0417             nan     0.0100    0.0001
     6        0.0410             nan     0.0100    0.0005
     7        0.0403             nan     0.0100    0.0007
     8        0.0396             nan     0.0100    0.0006
     9        0.0390             nan     0.0100    0.0004
    10        0.0387             nan     0.0100    0.0001
    20        0.0340             nan     0.0100    0.0002
    40        0.0265             nan     0.0100    0.0004
    60        0.0210             nan     0.0100    0.0002
    80        0.0160             nan     0.0100    0.0002
   100        0.0126             nan     0.0100    0.0001
   120        0.0099             nan     0.0100    0.0001
   140        0.0080             nan     0.0100    0.0000
   160        0.0065             nan     0.0100   -0.0000
   180        0.0053             nan     0.0100    0.0000
   200        0.0044             nan     0.0100    0.0000

- Fold04: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold04: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0440             nan     0.0100    0.0003
     2        0.0435             nan     0.0100    0.0003
     3        0.0433             nan     0.0100    0.0000
     4        0.0426             nan     0.0100    0.0006
     5        0.0422             nan     0.0100    0.0003
     6        0.0416             nan     0.0100    0.0005
     7        0.0411             nan     0.0100    0.0004
     8        0.0407             nan     0.0100    0.0003
     9        0.0403             nan     0.0100    0.0003
    10        0.0398             nan     0.0100    0.0003
    20        0.0349             nan     0.0100    0.0004
    40        0.0275             nan     0.0100    0.0001
    60        0.0227             nan     0.0100    0.0001
    80        0.0187             nan     0.0100    0.0002
   100        0.0159             nan     0.0100    0.0002
   120        0.0138             nan     0.0100    0.0000
   140        0.0122             nan     0.0100    0.0000
   160        0.0105             nan     0.0100    0.0001
   180        0.0093             nan     0.0100    0.0000
   200        0.0083             nan     0.0100    0.0000

- Fold04: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold04: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0437             nan     0.0100    0.0003
     2        0.0434             nan     0.0100    0.0000
     3        0.0427             nan     0.0100    0.0004
     4        0.0420             nan     0.0100    0.0007
     5        0.0414             nan     0.0100    0.0008
     6        0.0406             nan     0.0100    0.0004
     7        0.0399             nan     0.0100    0.0005
     8        0.0394             nan     0.0100    0.0005
     9        0.0390             nan     0.0100    0.0004
    10        0.0384             nan     0.0100    0.0004
    20        0.0331             nan     0.0100    0.0004
    40        0.0248             nan     0.0100    0.0005
    60        0.0188             nan     0.0100    0.0001
    80        0.0146             nan     0.0100   -0.0000
   100        0.0116             nan     0.0100   -0.0000
   120        0.0090             nan     0.0100    0.0001
   140        0.0071             nan     0.0100    0.0001
   160        0.0055             nan     0.0100    0.0000
   180        0.0042             nan     0.0100   -0.0000
   200        0.0034             nan     0.0100    0.0000

- Fold04: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold04: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0436             nan     0.0100    0.0003
     2        0.0432             nan     0.0100    0.0004
     3        0.0427             nan     0.0100    0.0002
     4        0.0420             nan     0.0100    0.0005
     5        0.0415             nan     0.0100    0.0004
     6        0.0407             nan     0.0100    0.0004
     7        0.0402             nan     0.0100    0.0005
     8        0.0394             nan     0.0100    0.0007
     9        0.0388             nan     0.0100    0.0004
    10        0.0382             nan     0.0100    0.0004
    20        0.0329             nan     0.0100    0.0005
    40        0.0252             nan     0.0100    0.0002
    60        0.0191             nan     0.0100    0.0002
    80        0.0148             nan     0.0100    0.0002
   100        0.0119             nan     0.0100    0.0001
   120        0.0093             nan     0.0100    0.0001
   140        0.0076             nan     0.0100    0.0001
   160        0.0062             nan     0.0100    0.0000
   180        0.0050             nan     0.0100    0.0000
   200        0.0042             nan     0.0100   -0.0000

- Fold04: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold04: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0438             nan     0.0100    0.0001
     2        0.0431             nan     0.0100    0.0006
     3        0.0426             nan     0.0100    0.0006
     4        0.0423             nan     0.0100    0.0002
     5        0.0421             nan     0.0100   -0.0001
     6        0.0418             nan     0.0100    0.0002
     7        0.0413             nan     0.0100    0.0005
     8        0.0406             nan     0.0100    0.0006
     9        0.0400             nan     0.0100    0.0004
    10        0.0396             nan     0.0100    0.0003
    20        0.0357             nan     0.0100    0.0001
    40        0.0287             nan     0.0100    0.0003
    60        0.0233             nan     0.0100    0.0001
    80        0.0193             nan     0.0100    0.0002
   100        0.0167             nan     0.0100    0.0002
   120        0.0143             nan     0.0100    0.0001
   140        0.0124             nan     0.0100    0.0001
   160        0.0106             nan     0.0100    0.0001
   180        0.0093             nan     0.0100   -0.0000
   200        0.0082             nan     0.0100    0.0000

- Fold04: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold04: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0416             nan     0.0500    0.0023
     2        0.0382             nan     0.0500    0.0032
     3        0.0356             nan     0.0500    0.0023
     4        0.0332             nan     0.0500    0.0016
     5        0.0307             nan     0.0500    0.0021
     6        0.0287             nan     0.0500    0.0014
     7        0.0271             nan     0.0500    0.0006
     8        0.0259             nan     0.0500    0.0014
     9        0.0249             nan     0.0500   -0.0002
    10        0.0241             nan     0.0500    0.0005
    20        0.0144             nan     0.0500    0.0007
    40        0.0060             nan     0.0500   -0.0000
    60        0.0032             nan     0.0500    0.0000
    80        0.0016             nan     0.0500    0.0000
   100        0.0010             nan     0.0500   -0.0000
   120        0.0006             nan     0.0500    0.0000
   140        0.0004             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500    0.0000
   180        0.0002             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold04: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold04: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0423             nan     0.0500    0.0017
     2        0.0387             nan     0.0500    0.0029
     3        0.0361             nan     0.0500    0.0022
     4        0.0342             nan     0.0500    0.0012
     5        0.0323             nan     0.0500    0.0019
     6        0.0304             nan     0.0500    0.0019
     7        0.0290             nan     0.0500    0.0011
     8        0.0276             nan     0.0500    0.0011
     9        0.0257             nan     0.0500    0.0012
    10        0.0248             nan     0.0500    0.0007
    20        0.0159             nan     0.0500    0.0006
    40        0.0067             nan     0.0500    0.0002
    60        0.0032             nan     0.0500    0.0001
    80        0.0018             nan     0.0500    0.0000
   100        0.0011             nan     0.0500    0.0000
   120        0.0006             nan     0.0500    0.0000
   140        0.0004             nan     0.0500   -0.0000
   160        0.0003             nan     0.0500   -0.0000
   180        0.0002             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500    0.0000

- Fold04: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold04: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0422             nan     0.0500    0.0027
     2        0.0404             nan     0.0500    0.0019
     3        0.0375             nan     0.0500    0.0027
     4        0.0350             nan     0.0500    0.0017
     5        0.0329             nan     0.0500    0.0015
     6        0.0306             nan     0.0500    0.0022
     7        0.0293             nan     0.0500    0.0009
     8        0.0280             nan     0.0500    0.0006
     9        0.0268             nan     0.0500    0.0009
    10        0.0254             nan     0.0500    0.0013
    20        0.0153             nan     0.0500    0.0003
    40        0.0081             nan     0.0500   -0.0001
    60        0.0048             nan     0.0500    0.0001
    80        0.0031             nan     0.0500   -0.0001
   100        0.0022             nan     0.0500   -0.0000
   120        0.0015             nan     0.0500   -0.0000
   140        0.0010             nan     0.0500    0.0000
   160        0.0007             nan     0.0500    0.0000
   180        0.0005             nan     0.0500   -0.0000
   200        0.0004             nan     0.0500   -0.0000

- Fold04: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold04: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0411             nan     0.0500    0.0022
     2        0.0379             nan     0.0500    0.0023
     3        0.0356             nan     0.0500    0.0020
     4        0.0326             nan     0.0500    0.0016
     5        0.0303             nan     0.0500    0.0014
     6        0.0283             nan     0.0500    0.0009
     7        0.0262             nan     0.0500    0.0020
     8        0.0258             nan     0.0500   -0.0010
     9        0.0234             nan     0.0500    0.0017
    10        0.0223             nan     0.0500    0.0011
    20        0.0126             nan     0.0500    0.0001
    40        0.0041             nan     0.0500    0.0004
    60        0.0016             nan     0.0500    0.0000
    80        0.0006             nan     0.0500    0.0000
   100        0.0003             nan     0.0500   -0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0001             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold04: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold04: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0411             nan     0.0500    0.0020
     2        0.0385             nan     0.0500    0.0021
     3        0.0361             nan     0.0500    0.0025
     4        0.0340             nan     0.0500    0.0014
     5        0.0311             nan     0.0500    0.0026
     6        0.0285             nan     0.0500    0.0011
     7        0.0259             nan     0.0500    0.0018
     8        0.0239             nan     0.0500    0.0014
     9        0.0230             nan     0.0500    0.0002
    10        0.0216             nan     0.0500    0.0014
    20        0.0115             nan     0.0500    0.0001
    40        0.0044             nan     0.0500    0.0000
    60        0.0022             nan     0.0500   -0.0000
    80        0.0010             nan     0.0500   -0.0000
   100        0.0006             nan     0.0500    0.0000
   120        0.0004             nan     0.0500   -0.0000
   140        0.0002             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500    0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold04: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold04: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0414             nan     0.0500    0.0031
     2        0.0394             nan     0.0500    0.0014
     3        0.0377             nan     0.0500    0.0016
     4        0.0353             nan     0.0500    0.0015
     5        0.0330             nan     0.0500    0.0013
     6        0.0315             nan     0.0500    0.0008
     7        0.0309             nan     0.0500   -0.0003
     8        0.0290             nan     0.0500    0.0020
     9        0.0281             nan     0.0500    0.0008
    10        0.0270             nan     0.0500    0.0008
    20        0.0164             nan     0.0500    0.0007
    40        0.0076             nan     0.0500    0.0003
    60        0.0042             nan     0.0500   -0.0001
    80        0.0025             nan     0.0500   -0.0001
   100        0.0017             nan     0.0500   -0.0000
   120        0.0013             nan     0.0500   -0.0000
   140        0.0008             nan     0.0500    0.0000
   160        0.0006             nan     0.0500    0.0000
   180        0.0004             nan     0.0500   -0.0000
   200        0.0003             nan     0.0500   -0.0000

- Fold04: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold04: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0409             nan     0.0500    0.0029
     2        0.0381             nan     0.0500    0.0024
     3        0.0349             nan     0.0500    0.0014
     4        0.0341             nan     0.0500   -0.0003
     5        0.0325             nan     0.0500    0.0015
     6        0.0301             nan     0.0500    0.0015
     7        0.0285             nan     0.0500    0.0011
     8        0.0266             nan     0.0500    0.0024
     9        0.0250             nan     0.0500    0.0000
    10        0.0237             nan     0.0500    0.0008
    20        0.0129             nan     0.0500    0.0008
    40        0.0036             nan     0.0500    0.0002
    60        0.0013             nan     0.0500    0.0000
    80        0.0005             nan     0.0500    0.0000
   100        0.0002             nan     0.0500    0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0000             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold04: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold04: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0411             nan     0.0500    0.0012
     2        0.0377             nan     0.0500    0.0011
     3        0.0350             nan     0.0500    0.0025
     4        0.0325             nan     0.0500    0.0015
     5        0.0303             nan     0.0500    0.0017
     6        0.0280             nan     0.0500    0.0016
     7        0.0263             nan     0.0500    0.0019
     8        0.0245             nan     0.0500    0.0015
     9        0.0242             nan     0.0500   -0.0009
    10        0.0236             nan     0.0500    0.0002
    20        0.0123             nan     0.0500    0.0004
    40        0.0048             nan     0.0500   -0.0000
    60        0.0017             nan     0.0500   -0.0000
    80        0.0009             nan     0.0500    0.0000
   100        0.0005             nan     0.0500    0.0000
   120        0.0003             nan     0.0500   -0.0000
   140        0.0002             nan     0.0500   -0.0000
   160        0.0001             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500    0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold04: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold04: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0413             nan     0.0500    0.0030
     2        0.0386             nan     0.0500    0.0016
     3        0.0367             nan     0.0500    0.0018
     4        0.0355             nan     0.0500   -0.0002
     5        0.0339             nan     0.0500    0.0012
     6        0.0316             nan     0.0500    0.0022
     7        0.0300             nan     0.0500    0.0000
     8        0.0286             nan     0.0500    0.0003
     9        0.0273             nan     0.0500    0.0008
    10        0.0263             nan     0.0500    0.0009
    20        0.0165             nan     0.0500    0.0002
    40        0.0090             nan     0.0500    0.0001
    60        0.0054             nan     0.0500    0.0001
    80        0.0038             nan     0.0500   -0.0001
   100        0.0027             nan     0.0500   -0.0000
   120        0.0020             nan     0.0500    0.0000
   140        0.0014             nan     0.0500    0.0000
   160        0.0011             nan     0.0500   -0.0000
   180        0.0008             nan     0.0500    0.0000
   200        0.0006             nan     0.0500    0.0000

- Fold04: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold04: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0380             nan     0.1000    0.0032
     2        0.0322             nan     0.1000    0.0050
     3        0.0289             nan     0.1000    0.0041
     4        0.0272             nan     0.1000    0.0010
     5        0.0239             nan     0.1000    0.0010
     6        0.0205             nan     0.1000    0.0026
     7        0.0184             nan     0.1000    0.0018
     8        0.0156             nan     0.1000    0.0035
     9        0.0136             nan     0.1000    0.0015
    10        0.0127             nan     0.1000    0.0001
    20        0.0046             nan     0.1000    0.0000
    40        0.0013             nan     0.1000    0.0000
    60        0.0005             nan     0.1000    0.0000
    80        0.0002             nan     0.1000    0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000    0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold04: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold04: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0395             nan     0.1000    0.0052
     2        0.0339             nan     0.1000    0.0036
     3        0.0329             nan     0.1000   -0.0017
     4        0.0291             nan     0.1000    0.0014
     5        0.0261             nan     0.1000    0.0026
     6        0.0238             nan     0.1000    0.0016
     7        0.0218             nan     0.1000    0.0008
     8        0.0200             nan     0.1000    0.0013
     9        0.0182             nan     0.1000    0.0011
    10        0.0168             nan     0.1000    0.0008
    20        0.0074             nan     0.1000    0.0003
    40        0.0024             nan     0.1000    0.0001
    60        0.0010             nan     0.1000   -0.0001
    80        0.0006             nan     0.1000   -0.0000
   100        0.0003             nan     0.1000    0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold04: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold04: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0395             nan     0.1000    0.0036
     2        0.0363             nan     0.1000    0.0034
     3        0.0312             nan     0.1000    0.0048
     4        0.0264             nan     0.1000    0.0034
     5        0.0230             nan     0.1000    0.0017
     6        0.0206             nan     0.1000    0.0022
     7        0.0198             nan     0.1000    0.0008
     8        0.0178             nan     0.1000    0.0018
     9        0.0167             nan     0.1000    0.0005
    10        0.0152             nan     0.1000    0.0013
    20        0.0081             nan     0.1000    0.0004
    40        0.0032             nan     0.1000    0.0001
    60        0.0016             nan     0.1000    0.0000
    80        0.0009             nan     0.1000   -0.0001
   100        0.0006             nan     0.1000   -0.0000
   120        0.0003             nan     0.1000    0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold04: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold04: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0375             nan     0.1000    0.0064
     2        0.0325             nan     0.1000    0.0052
     3        0.0271             nan     0.1000    0.0054
     4        0.0223             nan     0.1000    0.0047
     5        0.0191             nan     0.1000    0.0022
     6        0.0179             nan     0.1000    0.0005
     7        0.0177             nan     0.1000   -0.0020
     8        0.0149             nan     0.1000    0.0023
     9        0.0135             nan     0.1000    0.0013
    10        0.0121             nan     0.1000    0.0013
    20        0.0043             nan     0.1000   -0.0000
    40        0.0009             nan     0.1000   -0.0000
    60        0.0003             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold04: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold04: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0369             nan     0.1000    0.0066
     2        0.0318             nan     0.1000    0.0042
     3        0.0266             nan     0.1000    0.0043
     4        0.0251             nan     0.1000   -0.0026
     5        0.0213             nan     0.1000    0.0023
     6        0.0195             nan     0.1000    0.0015
     7        0.0170             nan     0.1000    0.0019
     8        0.0150             nan     0.1000    0.0021
     9        0.0130             nan     0.1000    0.0008
    10        0.0109             nan     0.1000    0.0008
    20        0.0043             nan     0.1000    0.0000
    40        0.0009             nan     0.1000    0.0000
    60        0.0003             nan     0.1000    0.0000
    80        0.0001             nan     0.1000    0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold04: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold04: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0391             nan     0.1000    0.0061
     2        0.0337             nan     0.1000    0.0046
     3        0.0299             nan     0.1000    0.0038
     4        0.0259             nan     0.1000    0.0033
     5        0.0242             nan     0.1000    0.0014
     6        0.0227             nan     0.1000    0.0012
     7        0.0212             nan     0.1000    0.0013
     8        0.0187             nan     0.1000    0.0004
     9        0.0167             nan     0.1000    0.0009
    10        0.0146             nan     0.1000    0.0008
    20        0.0076             nan     0.1000   -0.0004
    40        0.0036             nan     0.1000    0.0000
    60        0.0016             nan     0.1000   -0.0001
    80        0.0008             nan     0.1000   -0.0000
   100        0.0004             nan     0.1000   -0.0000
   120        0.0002             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold04: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold04: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0389             nan     0.1000    0.0050
     2        0.0327             nan     0.1000    0.0048
     3        0.0269             nan     0.1000    0.0040
     4        0.0222             nan     0.1000    0.0045
     5        0.0192             nan     0.1000    0.0010
     6        0.0167             nan     0.1000    0.0023
     7        0.0145             nan     0.1000    0.0016
     8        0.0132             nan     0.1000    0.0014
     9        0.0116             nan     0.1000    0.0005
    10        0.0103             nan     0.1000    0.0009
    20        0.0029             nan     0.1000    0.0003
    40        0.0003             nan     0.1000    0.0000
    60        0.0001             nan     0.1000   -0.0000
    80        0.0000             nan     0.1000    0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold04: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold04: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0386             nan     0.1000    0.0051
     2        0.0350             nan     0.1000    0.0045
     3        0.0300             nan     0.1000    0.0031
     4        0.0265             nan     0.1000    0.0035
     5        0.0233             nan     0.1000    0.0034
     6        0.0209             nan     0.1000    0.0021
     7        0.0177             nan     0.1000    0.0023
     8        0.0164             nan     0.1000    0.0017
     9        0.0152             nan     0.1000    0.0015
    10        0.0142             nan     0.1000    0.0005
    20        0.0047             nan     0.1000    0.0004
    40        0.0011             nan     0.1000   -0.0000
    60        0.0004             nan     0.1000    0.0000
    80        0.0002             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000    0.0000

- Fold04: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold04: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0388             nan     0.1000    0.0059
     2        0.0356             nan     0.1000    0.0021
     3        0.0303             nan     0.1000    0.0041
     4        0.0269             nan     0.1000    0.0016
     5        0.0246             nan     0.1000    0.0013
     6        0.0223             nan     0.1000    0.0025
     7        0.0206             nan     0.1000    0.0014
     8        0.0193             nan     0.1000    0.0013
     9        0.0168             nan     0.1000    0.0014
    10        0.0147             nan     0.1000    0.0008
    20        0.0078             nan     0.1000   -0.0001
    40        0.0034             nan     0.1000   -0.0000
    60        0.0016             nan     0.1000    0.0000
    80        0.0008             nan     0.1000    0.0000
   100        0.0005             nan     0.1000   -0.0000
   120        0.0003             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000    0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold04: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold05: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0430             nan     0.0100    0.0005
     2        0.0425             nan     0.0100    0.0005
     3        0.0421             nan     0.0100    0.0002
     4        0.0414             nan     0.0100    0.0006
     5        0.0410             nan     0.0100    0.0005
     6        0.0405             nan     0.0100    0.0006
     7        0.0401             nan     0.0100    0.0003
     8        0.0396             nan     0.0100    0.0004
     9        0.0391             nan     0.0100    0.0005
    10        0.0387             nan     0.0100    0.0002
    20        0.0348             nan     0.0100    0.0004
    40        0.0276             nan     0.0100    0.0003
    60        0.0227             nan     0.0100    0.0002
    80        0.0186             nan     0.0100    0.0001
   100        0.0151             nan     0.0100    0.0002
   120        0.0124             nan     0.0100    0.0000
   140        0.0103             nan     0.0100   -0.0000
   160        0.0087             nan     0.0100    0.0000
   180        0.0072             nan     0.0100    0.0000
   200        0.0062             nan     0.0100    0.0000

- Fold05: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold05: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0431             nan     0.0100    0.0005
     2        0.0426             nan     0.0100    0.0004
     3        0.0421             nan     0.0100    0.0005
     4        0.0415             nan     0.0100    0.0005
     5        0.0409             nan     0.0100    0.0006
     6        0.0403             nan     0.0100    0.0005
     7        0.0400             nan     0.0100    0.0002
     8        0.0394             nan     0.0100    0.0006
     9        0.0389             nan     0.0100    0.0003
    10        0.0383             nan     0.0100    0.0004
    20        0.0340             nan     0.0100    0.0003
    40        0.0271             nan     0.0100    0.0003
    60        0.0218             nan     0.0100    0.0001
    80        0.0175             nan     0.0100    0.0002
   100        0.0146             nan     0.0100   -0.0000
   120        0.0122             nan     0.0100    0.0000
   140        0.0100             nan     0.0100    0.0001
   160        0.0085             nan     0.0100   -0.0001
   180        0.0074             nan     0.0100    0.0001
   200        0.0063             nan     0.0100    0.0000

- Fold05: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold05: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0432             nan     0.0100    0.0003
     2        0.0426             nan     0.0100    0.0005
     3        0.0421             nan     0.0100    0.0004
     4        0.0415             nan     0.0100    0.0005
     5        0.0411             nan     0.0100    0.0004
     6        0.0405             nan     0.0100    0.0005
     7        0.0402             nan     0.0100    0.0000
     8        0.0397             nan     0.0100    0.0005
     9        0.0391             nan     0.0100    0.0005
    10        0.0386             nan     0.0100    0.0004
    20        0.0344             nan     0.0100    0.0003
    40        0.0277             nan     0.0100    0.0000
    60        0.0223             nan     0.0100    0.0002
    80        0.0190             nan     0.0100    0.0001
   100        0.0158             nan     0.0100    0.0001
   120        0.0133             nan     0.0100    0.0001
   140        0.0117             nan     0.0100    0.0000
   160        0.0100             nan     0.0100    0.0000
   180        0.0089             nan     0.0100    0.0000
   200        0.0080             nan     0.0100    0.0000

- Fold05: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold05: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0430             nan     0.0100    0.0004
     2        0.0423             nan     0.0100    0.0005
     3        0.0417             nan     0.0100    0.0005
     4        0.0411             nan     0.0100    0.0002
     5        0.0403             nan     0.0100    0.0006
     6        0.0401             nan     0.0100   -0.0001
     7        0.0395             nan     0.0100    0.0005
     8        0.0390             nan     0.0100    0.0004
     9        0.0384             nan     0.0100    0.0004
    10        0.0379             nan     0.0100    0.0005
    20        0.0329             nan     0.0100    0.0004
    40        0.0244             nan     0.0100    0.0004
    60        0.0190             nan     0.0100    0.0003
    80        0.0145             nan     0.0100    0.0002
   100        0.0113             nan     0.0100    0.0001
   120        0.0092             nan     0.0100    0.0001
   140        0.0074             nan     0.0100    0.0001
   160        0.0060             nan     0.0100    0.0000
   180        0.0048             nan     0.0100    0.0001
   200        0.0040             nan     0.0100    0.0000

- Fold05: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold05: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0431             nan     0.0100    0.0003
     2        0.0424             nan     0.0100    0.0004
     3        0.0419             nan     0.0100    0.0004
     4        0.0414             nan     0.0100    0.0006
     5        0.0408             nan     0.0100    0.0005
     6        0.0402             nan     0.0100    0.0005
     7        0.0396             nan     0.0100    0.0004
     8        0.0391             nan     0.0100    0.0005
     9        0.0388             nan     0.0100    0.0001
    10        0.0382             nan     0.0100    0.0005
    20        0.0336             nan     0.0100    0.0002
    40        0.0259             nan     0.0100    0.0004
    60        0.0204             nan     0.0100    0.0002
    80        0.0159             nan     0.0100    0.0001
   100        0.0124             nan     0.0100    0.0002
   120        0.0099             nan     0.0100    0.0001
   140        0.0081             nan     0.0100    0.0001
   160        0.0065             nan     0.0100    0.0000
   180        0.0053             nan     0.0100   -0.0000
   200        0.0044             nan     0.0100    0.0000

- Fold05: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold05: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0432             nan     0.0100    0.0000
     2        0.0427             nan     0.0100    0.0004
     3        0.0422             nan     0.0100    0.0005
     4        0.0415             nan     0.0100    0.0006
     5        0.0412             nan     0.0100    0.0003
     6        0.0407             nan     0.0100    0.0005
     7        0.0402             nan     0.0100    0.0005
     8        0.0395             nan     0.0100    0.0003
     9        0.0390             nan     0.0100    0.0005
    10        0.0385             nan     0.0100    0.0003
    20        0.0350             nan     0.0100    0.0000
    40        0.0279             nan     0.0100    0.0003
    60        0.0229             nan     0.0100    0.0001
    80        0.0193             nan     0.0100    0.0001
   100        0.0163             nan     0.0100    0.0002
   120        0.0142             nan     0.0100    0.0001
   140        0.0122             nan     0.0100    0.0001
   160        0.0106             nan     0.0100   -0.0001
   180        0.0094             nan     0.0100    0.0000
   200        0.0084             nan     0.0100    0.0000

- Fold05: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold05: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0429             nan     0.0100    0.0005
     2        0.0424             nan     0.0100    0.0003
     3        0.0416             nan     0.0100    0.0006
     4        0.0410             nan     0.0100    0.0005
     5        0.0403             nan     0.0100    0.0005
     6        0.0399             nan     0.0100    0.0002
     7        0.0391             nan     0.0100    0.0005
     8        0.0384             nan     0.0100    0.0007
     9        0.0378             nan     0.0100    0.0003
    10        0.0372             nan     0.0100    0.0007
    20        0.0321             nan     0.0100    0.0006
    40        0.0240             nan     0.0100    0.0001
    60        0.0179             nan     0.0100    0.0001
    80        0.0131             nan     0.0100    0.0001
   100        0.0100             nan     0.0100    0.0001
   120        0.0078             nan     0.0100    0.0001
   140        0.0061             nan     0.0100    0.0001
   160        0.0049             nan     0.0100    0.0000
   180        0.0039             nan     0.0100    0.0000
   200        0.0030             nan     0.0100    0.0000

- Fold05: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold05: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0429             nan     0.0100    0.0007
     2        0.0425             nan     0.0100    0.0004
     3        0.0421             nan     0.0100    0.0003
     4        0.0416             nan     0.0100    0.0003
     5        0.0413             nan     0.0100    0.0000
     6        0.0407             nan     0.0100    0.0006
     7        0.0399             nan     0.0100    0.0005
     8        0.0393             nan     0.0100    0.0004
     9        0.0387             nan     0.0100    0.0003
    10        0.0383             nan     0.0100    0.0005
    20        0.0333             nan     0.0100    0.0004
    40        0.0260             nan     0.0100    0.0001
    60        0.0205             nan     0.0100    0.0003
    80        0.0154             nan     0.0100    0.0001
   100        0.0121             nan     0.0100    0.0001
   120        0.0096             nan     0.0100    0.0001
   140        0.0076             nan     0.0100    0.0000
   160        0.0062             nan     0.0100   -0.0001
   180        0.0052             nan     0.0100    0.0000
   200        0.0042             nan     0.0100    0.0000

- Fold05: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold05: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0429             nan     0.0100    0.0006
     2        0.0427             nan     0.0100   -0.0002
     3        0.0420             nan     0.0100    0.0006
     4        0.0417             nan     0.0100    0.0004
     5        0.0411             nan     0.0100    0.0004
     6        0.0405             nan     0.0100    0.0006
     7        0.0398             nan     0.0100    0.0005
     8        0.0395             nan     0.0100    0.0000
     9        0.0389             nan     0.0100    0.0002
    10        0.0385             nan     0.0100    0.0005
    20        0.0340             nan     0.0100   -0.0001
    40        0.0275             nan     0.0100    0.0002
    60        0.0223             nan     0.0100   -0.0000
    80        0.0186             nan     0.0100    0.0001
   100        0.0153             nan     0.0100    0.0000
   120        0.0134             nan     0.0100    0.0000
   140        0.0117             nan     0.0100    0.0000
   160        0.0101             nan     0.0100   -0.0000
   180        0.0090             nan     0.0100    0.0000
   200        0.0082             nan     0.0100   -0.0000

- Fold05: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold05: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0409             nan     0.0500    0.0017
     2        0.0378             nan     0.0500    0.0025
     3        0.0349             nan     0.0500    0.0026
     4        0.0327             nan     0.0500    0.0021
     5        0.0316             nan     0.0500    0.0002
     6        0.0293             nan     0.0500    0.0016
     7        0.0282             nan     0.0500    0.0010
     8        0.0265             nan     0.0500    0.0010
     9        0.0247             nan     0.0500    0.0013
    10        0.0236             nan     0.0500    0.0010
    20        0.0142             nan     0.0500    0.0006
    40        0.0061             nan     0.0500    0.0000
    60        0.0028             nan     0.0500    0.0001
    80        0.0015             nan     0.0500   -0.0000
   100        0.0009             nan     0.0500   -0.0000
   120        0.0005             nan     0.0500    0.0000
   140        0.0003             nan     0.0500    0.0000
   160        0.0002             nan     0.0500    0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500    0.0000

- Fold05: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold05: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0415             nan     0.0500    0.0021
     2        0.0396             nan     0.0500    0.0013
     3        0.0385             nan     0.0500   -0.0004
     4        0.0363             nan     0.0500    0.0026
     5        0.0339             nan     0.0500    0.0025
     6        0.0316             nan     0.0500    0.0019
     7        0.0297             nan     0.0500    0.0017
     8        0.0284             nan     0.0500    0.0014
     9        0.0263             nan     0.0500    0.0008
    10        0.0250             nan     0.0500    0.0008
    20        0.0144             nan     0.0500    0.0007
    40        0.0064             nan     0.0500    0.0002
    60        0.0033             nan     0.0500   -0.0001
    80        0.0019             nan     0.0500   -0.0000
   100        0.0010             nan     0.0500   -0.0000
   120        0.0007             nan     0.0500   -0.0000
   140        0.0004             nan     0.0500   -0.0000
   160        0.0003             nan     0.0500    0.0000
   180        0.0002             nan     0.0500    0.0000
   200        0.0001             nan     0.0500    0.0000

- Fold05: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold05: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0437             nan     0.0500   -0.0013
     2        0.0405             nan     0.0500    0.0028
     3        0.0377             nan     0.0500    0.0020
     4        0.0367             nan     0.0500    0.0007
     5        0.0346             nan     0.0500    0.0020
     6        0.0329             nan     0.0500    0.0007
     7        0.0318             nan     0.0500    0.0012
     8        0.0300             nan     0.0500    0.0019
     9        0.0281             nan     0.0500    0.0017
    10        0.0269             nan     0.0500    0.0014
    20        0.0188             nan     0.0500    0.0002
    40        0.0096             nan     0.0500    0.0002
    60        0.0055             nan     0.0500   -0.0002
    80        0.0037             nan     0.0500   -0.0000
   100        0.0025             nan     0.0500    0.0000
   120        0.0019             nan     0.0500    0.0000
   140        0.0013             nan     0.0500   -0.0000
   160        0.0009             nan     0.0500    0.0000
   180        0.0007             nan     0.0500   -0.0000
   200        0.0006             nan     0.0500   -0.0000

- Fold05: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold05: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0399             nan     0.0500    0.0026
     2        0.0368             nan     0.0500    0.0032
     3        0.0340             nan     0.0500    0.0024
     4        0.0329             nan     0.0500   -0.0011
     5        0.0307             nan     0.0500    0.0016
     6        0.0291             nan     0.0500    0.0016
     7        0.0280             nan     0.0500    0.0007
     8        0.0263             nan     0.0500    0.0017
     9        0.0248             nan     0.0500    0.0006
    10        0.0236             nan     0.0500    0.0009
    20        0.0132             nan     0.0500   -0.0002
    40        0.0038             nan     0.0500    0.0001
    60        0.0015             nan     0.0500    0.0000
    80        0.0006             nan     0.0500   -0.0000
   100        0.0003             nan     0.0500    0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0001             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold05: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold05: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0406             nan     0.0500    0.0024
     2        0.0368             nan     0.0500    0.0030
     3        0.0348             nan     0.0500    0.0014
     4        0.0319             nan     0.0500    0.0019
     5        0.0306             nan     0.0500    0.0008
     6        0.0282             nan     0.0500    0.0019
     7        0.0266             nan     0.0500    0.0006
     8        0.0260             nan     0.0500   -0.0003
     9        0.0247             nan     0.0500    0.0013
    10        0.0234             nan     0.0500    0.0009
    20        0.0136             nan     0.0500    0.0005
    40        0.0045             nan     0.0500   -0.0000
    60        0.0020             nan     0.0500   -0.0000
    80        0.0010             nan     0.0500   -0.0000
   100        0.0006             nan     0.0500   -0.0000
   120        0.0003             nan     0.0500   -0.0000
   140        0.0002             nan     0.0500    0.0000
   160        0.0001             nan     0.0500    0.0000
   180        0.0001             nan     0.0500    0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold05: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold05: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0408             nan     0.0500    0.0029
     2        0.0392             nan     0.0500    0.0009
     3        0.0378             nan     0.0500    0.0010
     4        0.0353             nan     0.0500    0.0016
     5        0.0335             nan     0.0500    0.0020
     6        0.0326             nan     0.0500    0.0004
     7        0.0313             nan     0.0500   -0.0003
     8        0.0300             nan     0.0500    0.0008
     9        0.0287             nan     0.0500    0.0012
    10        0.0269             nan     0.0500    0.0017
    20        0.0167             nan     0.0500    0.0003
    40        0.0086             nan     0.0500   -0.0003
    60        0.0048             nan     0.0500    0.0000
    80        0.0033             nan     0.0500   -0.0001
   100        0.0022             nan     0.0500    0.0000
   120        0.0016             nan     0.0500   -0.0000
   140        0.0011             nan     0.0500    0.0000
   160        0.0008             nan     0.0500    0.0000
   180        0.0007             nan     0.0500   -0.0000
   200        0.0005             nan     0.0500    0.0000

- Fold05: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold05: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0399             nan     0.0500    0.0028
     2        0.0366             nan     0.0500    0.0020
     3        0.0334             nan     0.0500    0.0017
     4        0.0303             nan     0.0500    0.0017
     5        0.0276             nan     0.0500    0.0016
     6        0.0249             nan     0.0500    0.0023
     7        0.0223             nan     0.0500    0.0017
     8        0.0208             nan     0.0500    0.0005
     9        0.0189             nan     0.0500    0.0012
    10        0.0178             nan     0.0500    0.0004
    20        0.0088             nan     0.0500    0.0005
    40        0.0025             nan     0.0500    0.0001
    60        0.0009             nan     0.0500    0.0000
    80        0.0003             nan     0.0500    0.0000
   100        0.0002             nan     0.0500   -0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0000             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold05: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold05: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0403             nan     0.0500    0.0024
     2        0.0379             nan     0.0500    0.0017
     3        0.0365             nan     0.0500   -0.0012
     4        0.0339             nan     0.0500    0.0024
     5        0.0316             nan     0.0500    0.0020
     6        0.0295             nan     0.0500    0.0020
     7        0.0277             nan     0.0500    0.0001
     8        0.0257             nan     0.0500    0.0018
     9        0.0244             nan     0.0500    0.0008
    10        0.0222             nan     0.0500    0.0015
    20        0.0117             nan     0.0500    0.0006
    40        0.0048             nan     0.0500    0.0001
    60        0.0017             nan     0.0500   -0.0000
    80        0.0010             nan     0.0500    0.0000
   100        0.0006             nan     0.0500   -0.0000
   120        0.0003             nan     0.0500    0.0000
   140        0.0003             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500    0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold05: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold05: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0409             nan     0.0500    0.0027
     2        0.0382             nan     0.0500    0.0024
     3        0.0374             nan     0.0500    0.0001
     4        0.0355             nan     0.0500    0.0016
     5        0.0334             nan     0.0500    0.0013
     6        0.0314             nan     0.0500    0.0022
     7        0.0303             nan     0.0500    0.0014
     8        0.0290             nan     0.0500    0.0014
     9        0.0271             nan     0.0500    0.0018
    10        0.0254             nan     0.0500    0.0016
    20        0.0162             nan     0.0500    0.0004
    40        0.0078             nan     0.0500    0.0002
    60        0.0053             nan     0.0500   -0.0002
    80        0.0035             nan     0.0500    0.0000
   100        0.0024             nan     0.0500    0.0000
   120        0.0017             nan     0.0500    0.0000
   140        0.0011             nan     0.0500    0.0000
   160        0.0007             nan     0.0500   -0.0000
   180        0.0005             nan     0.0500   -0.0000
   200        0.0004             nan     0.0500   -0.0000

- Fold05: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold05: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0375             nan     0.1000    0.0061
     2        0.0336             nan     0.1000    0.0013
     3        0.0309             nan     0.1000    0.0023
     4        0.0274             nan     0.1000    0.0023
     5        0.0252             nan     0.1000    0.0015
     6        0.0237             nan     0.1000    0.0007
     7        0.0233             nan     0.1000   -0.0021
     8        0.0212             nan     0.1000    0.0025
     9        0.0185             nan     0.1000    0.0005
    10        0.0172             nan     0.1000   -0.0003
    20        0.0075             nan     0.1000   -0.0001
    40        0.0016             nan     0.1000    0.0000
    60        0.0006             nan     0.1000    0.0000
    80        0.0002             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000    0.0000
   120        0.0000             nan     0.1000    0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold05: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold05: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0387             nan     0.1000    0.0031
     2        0.0333             nan     0.1000    0.0052
     3        0.0310             nan     0.1000    0.0015
     4        0.0274             nan     0.1000    0.0038
     5        0.0243             nan     0.1000    0.0026
     6        0.0211             nan     0.1000    0.0025
     7        0.0181             nan     0.1000    0.0016
     8        0.0161             nan     0.1000    0.0019
     9        0.0141             nan     0.1000    0.0016
    10        0.0128             nan     0.1000    0.0013
    20        0.0063             nan     0.1000    0.0002
    40        0.0021             nan     0.1000   -0.0001
    60        0.0010             nan     0.1000   -0.0001
    80        0.0005             nan     0.1000    0.0000
   100        0.0003             nan     0.1000    0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000    0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold05: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold05: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0385             nan     0.1000    0.0043
     2        0.0349             nan     0.1000    0.0009
     3        0.0314             nan     0.1000    0.0028
     4        0.0270             nan     0.1000    0.0029
     5        0.0244             nan     0.1000    0.0018
     6        0.0229             nan     0.1000    0.0010
     7        0.0208             nan     0.1000    0.0017
     8        0.0201             nan     0.1000   -0.0016
     9        0.0190             nan     0.1000    0.0004
    10        0.0175             nan     0.1000    0.0009
    20        0.0098             nan     0.1000    0.0001
    40        0.0038             nan     0.1000   -0.0002
    60        0.0017             nan     0.1000   -0.0001
    80        0.0009             nan     0.1000    0.0000
   100        0.0005             nan     0.1000    0.0000
   120        0.0002             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000    0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold05: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold05: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0377             nan     0.1000    0.0063
     2        0.0344             nan     0.1000    0.0024
     3        0.0304             nan     0.1000    0.0044
     4        0.0264             nan     0.1000    0.0028
     5        0.0244             nan     0.1000    0.0014
     6        0.0219             nan     0.1000    0.0028
     7        0.0190             nan     0.1000    0.0027
     8        0.0160             nan     0.1000    0.0015
     9        0.0137             nan     0.1000    0.0010
    10        0.0124             nan     0.1000    0.0010
    20        0.0033             nan     0.1000    0.0003
    40        0.0007             nan     0.1000    0.0001
    60        0.0002             nan     0.1000    0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000    0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold05: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold05: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0386             nan     0.1000    0.0042
     2        0.0333             nan     0.1000    0.0041
     3        0.0306             nan     0.1000    0.0028
     4        0.0282             nan     0.1000    0.0020
     5        0.0244             nan     0.1000    0.0022
     6        0.0214             nan     0.1000    0.0020
     7        0.0192             nan     0.1000    0.0016
     8        0.0172             nan     0.1000    0.0016
     9        0.0150             nan     0.1000    0.0007
    10        0.0138             nan     0.1000    0.0008
    20        0.0055             nan     0.1000   -0.0001
    40        0.0010             nan     0.1000    0.0000
    60        0.0003             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold05: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold05: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0379             nan     0.1000    0.0057
     2        0.0352             nan     0.1000    0.0017
     3        0.0310             nan     0.1000    0.0023
     4        0.0280             nan     0.1000    0.0018
     5        0.0259             nan     0.1000    0.0019
     6        0.0232             nan     0.1000    0.0029
     7        0.0212             nan     0.1000    0.0023
     8        0.0189             nan     0.1000    0.0013
     9        0.0181             nan     0.1000    0.0002
    10        0.0169             nan     0.1000    0.0003
    20        0.0111             nan     0.1000   -0.0004
    40        0.0045             nan     0.1000   -0.0001
    60        0.0023             nan     0.1000    0.0001
    80        0.0014             nan     0.1000    0.0000
   100        0.0007             nan     0.1000   -0.0000
   120        0.0004             nan     0.1000    0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0002             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold05: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold05: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0358             nan     0.1000    0.0055
     2        0.0321             nan     0.1000    0.0032
     3        0.0280             nan     0.1000    0.0025
     4        0.0255             nan     0.1000   -0.0003
     5        0.0230             nan     0.1000    0.0019
     6        0.0194             nan     0.1000    0.0025
     7        0.0171             nan     0.1000    0.0026
     8        0.0142             nan     0.1000    0.0021
     9        0.0125             nan     0.1000    0.0005
    10        0.0108             nan     0.1000    0.0003
    20        0.0031             nan     0.1000    0.0002
    40        0.0005             nan     0.1000    0.0000
    60        0.0001             nan     0.1000   -0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000    0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold05: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold05: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0359             nan     0.1000    0.0052
     2        0.0303             nan     0.1000    0.0040
     3        0.0272             nan     0.1000    0.0033
     4        0.0254             nan     0.1000    0.0002
     5        0.0202             nan     0.1000    0.0035
     6        0.0180             nan     0.1000    0.0019
     7        0.0170             nan     0.1000    0.0004
     8        0.0156             nan     0.1000    0.0008
     9        0.0139             nan     0.1000    0.0010
    10        0.0121             nan     0.1000    0.0014
    20        0.0039             nan     0.1000    0.0002
    40        0.0009             nan     0.1000   -0.0000
    60        0.0004             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000    0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold05: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold05: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0376             nan     0.1000    0.0048
     2        0.0324             nan     0.1000    0.0024
     3        0.0278             nan     0.1000    0.0026
     4        0.0244             nan     0.1000    0.0021
     5        0.0222             nan     0.1000    0.0018
     6        0.0203             nan     0.1000    0.0016
     7        0.0180             nan     0.1000    0.0015
     8        0.0166             nan     0.1000    0.0009
     9        0.0153             nan     0.1000    0.0004
    10        0.0143             nan     0.1000    0.0004
    20        0.0076             nan     0.1000    0.0002
    40        0.0034             nan     0.1000   -0.0001
    60        0.0013             nan     0.1000    0.0001
    80        0.0006             nan     0.1000   -0.0000
   100        0.0003             nan     0.1000   -0.0000
   120        0.0002             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold05: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold06: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0424             nan     0.0100    0.0006
     2        0.0419             nan     0.0100    0.0002
     3        0.0413             nan     0.0100    0.0006
     4        0.0409             nan     0.0100    0.0005
     5        0.0407             nan     0.0100    0.0001
     6        0.0400             nan     0.0100    0.0003
     7        0.0396             nan     0.0100    0.0005
     8        0.0392             nan     0.0100    0.0002
     9        0.0389             nan     0.0100    0.0002
    10        0.0382             nan     0.0100    0.0005
    20        0.0339             nan     0.0100    0.0003
    40        0.0276             nan     0.0100    0.0000
    60        0.0220             nan     0.0100    0.0002
    80        0.0180             nan     0.0100    0.0002
   100        0.0148             nan     0.0100    0.0001
   120        0.0124             nan     0.0100   -0.0000
   140        0.0104             nan     0.0100    0.0000
   160        0.0086             nan     0.0100    0.0001
   180        0.0072             nan     0.0100    0.0000
   200        0.0061             nan     0.0100    0.0001

- Fold06: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold06: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0424             nan     0.0100    0.0004
     2        0.0418             nan     0.0100    0.0006
     3        0.0413             nan     0.0100    0.0005
     4        0.0408             nan     0.0100    0.0005
     5        0.0405             nan     0.0100    0.0002
     6        0.0401             nan     0.0100    0.0002
     7        0.0396             nan     0.0100    0.0005
     8        0.0391             nan     0.0100    0.0005
     9        0.0387             nan     0.0100    0.0001
    10        0.0381             nan     0.0100    0.0005
    20        0.0342             nan     0.0100    0.0003
    40        0.0271             nan     0.0100    0.0001
    60        0.0220             nan     0.0100    0.0002
    80        0.0186             nan     0.0100    0.0001
   100        0.0153             nan     0.0100    0.0001
   120        0.0127             nan     0.0100    0.0001
   140        0.0107             nan     0.0100    0.0001
   160        0.0090             nan     0.0100    0.0001
   180        0.0077             nan     0.0100    0.0001
   200        0.0065             nan     0.0100    0.0000

- Fold06: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold06: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0425             nan     0.0100    0.0004
     2        0.0418             nan     0.0100    0.0005
     3        0.0414             nan     0.0100    0.0003
     4        0.0409             nan     0.0100    0.0003
     5        0.0403             nan     0.0100    0.0006
     6        0.0398             nan     0.0100    0.0005
     7        0.0392             nan     0.0100    0.0004
     8        0.0388             nan     0.0100    0.0004
     9        0.0384             nan     0.0100    0.0005
    10        0.0378             nan     0.0100    0.0005
    20        0.0340             nan     0.0100    0.0004
    40        0.0268             nan     0.0100    0.0003
    60        0.0217             nan     0.0100    0.0001
    80        0.0184             nan     0.0100    0.0001
   100        0.0155             nan     0.0100    0.0001
   120        0.0133             nan     0.0100   -0.0000
   140        0.0113             nan     0.0100    0.0001
   160        0.0100             nan     0.0100   -0.0000
   180        0.0088             nan     0.0100    0.0000
   200        0.0079             nan     0.0100    0.0000

- Fold06: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold06: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0423             nan     0.0100    0.0005
     2        0.0417             nan     0.0100    0.0004
     3        0.0411             nan     0.0100    0.0005
     4        0.0403             nan     0.0100    0.0004
     5        0.0399             nan     0.0100    0.0002
     6        0.0394             nan     0.0100    0.0005
     7        0.0389             nan     0.0100    0.0005
     8        0.0381             nan     0.0100    0.0004
     9        0.0375             nan     0.0100    0.0006
    10        0.0369             nan     0.0100    0.0005
    20        0.0322             nan     0.0100    0.0005
    40        0.0246             nan     0.0100    0.0003
    60        0.0188             nan     0.0100    0.0002
    80        0.0150             nan     0.0100    0.0001
   100        0.0119             nan     0.0100    0.0001
   120        0.0091             nan     0.0100    0.0001
   140        0.0071             nan     0.0100    0.0001
   160        0.0057             nan     0.0100    0.0000
   180        0.0046             nan     0.0100    0.0000
   200        0.0037             nan     0.0100    0.0000

- Fold06: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold06: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0424             nan     0.0100    0.0004
     2        0.0421             nan     0.0100    0.0002
     3        0.0414             nan     0.0100    0.0006
     4        0.0407             nan     0.0100    0.0006
     5        0.0402             nan     0.0100    0.0003
     6        0.0395             nan     0.0100    0.0007
     7        0.0389             nan     0.0100    0.0002
     8        0.0384             nan     0.0100    0.0005
     9        0.0378             nan     0.0100    0.0004
    10        0.0372             nan     0.0100    0.0004
    20        0.0323             nan     0.0100    0.0005
    40        0.0246             nan     0.0100    0.0001
    60        0.0189             nan     0.0100    0.0002
    80        0.0145             nan     0.0100    0.0001
   100        0.0113             nan     0.0100    0.0001
   120        0.0091             nan     0.0100    0.0001
   140        0.0073             nan     0.0100    0.0000
   160        0.0061             nan     0.0100    0.0000
   180        0.0051             nan     0.0100    0.0000
   200        0.0041             nan     0.0100    0.0000

- Fold06: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold06: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0424             nan     0.0100    0.0006
     2        0.0420             nan     0.0100    0.0003
     3        0.0416             nan     0.0100    0.0003
     4        0.0411             nan     0.0100    0.0005
     5        0.0407             nan     0.0100    0.0004
     6        0.0400             nan     0.0100    0.0004
     7        0.0396             nan     0.0100    0.0005
     8        0.0393             nan     0.0100    0.0001
     9        0.0389             nan     0.0100    0.0002
    10        0.0384             nan     0.0100    0.0004
    20        0.0340             nan     0.0100    0.0004
    40        0.0281             nan     0.0100    0.0002
    60        0.0227             nan     0.0100    0.0000
    80        0.0191             nan     0.0100    0.0001
   100        0.0162             nan     0.0100    0.0001
   120        0.0139             nan     0.0100   -0.0000
   140        0.0119             nan     0.0100    0.0001
   160        0.0104             nan     0.0100    0.0000
   180        0.0089             nan     0.0100    0.0000
   200        0.0081             nan     0.0100   -0.0001

- Fold06: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold06: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0425             nan     0.0100    0.0005
     2        0.0420             nan     0.0100    0.0002
     3        0.0413             nan     0.0100    0.0002
     4        0.0406             nan     0.0100    0.0007
     5        0.0400             nan     0.0100    0.0003
     6        0.0396             nan     0.0100    0.0004
     7        0.0389             nan     0.0100    0.0006
     8        0.0383             nan     0.0100    0.0003
     9        0.0377             nan     0.0100    0.0005
    10        0.0371             nan     0.0100    0.0005
    20        0.0318             nan     0.0100    0.0005
    40        0.0242             nan     0.0100    0.0001
    60        0.0180             nan     0.0100    0.0002
    80        0.0139             nan     0.0100    0.0001
   100        0.0108             nan     0.0100    0.0002
   120        0.0084             nan     0.0100    0.0000
   140        0.0066             nan     0.0100    0.0000
   160        0.0053             nan     0.0100    0.0000
   180        0.0041             nan     0.0100    0.0000
   200        0.0033             nan     0.0100    0.0000

- Fold06: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold06: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0425             nan     0.0100    0.0003
     2        0.0418             nan     0.0100    0.0005
     3        0.0413             nan     0.0100    0.0001
     4        0.0405             nan     0.0100    0.0006
     5        0.0399             nan     0.0100    0.0006
     6        0.0394             nan     0.0100    0.0003
     7        0.0389             nan     0.0100    0.0005
     8        0.0385             nan     0.0100    0.0003
     9        0.0382             nan     0.0100    0.0002
    10        0.0379             nan     0.0100    0.0003
    20        0.0334             nan     0.0100    0.0002
    40        0.0259             nan     0.0100    0.0003
    60        0.0201             nan     0.0100    0.0002
    80        0.0160             nan     0.0100    0.0001
   100        0.0124             nan     0.0100    0.0001
   120        0.0100             nan     0.0100    0.0001
   140        0.0083             nan     0.0100    0.0000
   160        0.0068             nan     0.0100    0.0000
   180        0.0056             nan     0.0100    0.0000
   200        0.0046             nan     0.0100    0.0000

- Fold06: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold06: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0424             nan     0.0100    0.0005
     2        0.0417             nan     0.0100    0.0006
     3        0.0413             nan     0.0100    0.0005
     4        0.0408             nan     0.0100    0.0004
     5        0.0404             nan     0.0100    0.0005
     6        0.0402             nan     0.0100   -0.0001
     7        0.0396             nan     0.0100    0.0005
     8        0.0389             nan     0.0100    0.0003
     9        0.0386             nan     0.0100   -0.0000
    10        0.0381             nan     0.0100    0.0005
    20        0.0338             nan     0.0100    0.0003
    40        0.0272             nan     0.0100    0.0001
    60        0.0226             nan     0.0100    0.0001
    80        0.0188             nan     0.0100    0.0001
   100        0.0159             nan     0.0100    0.0001
   120        0.0136             nan     0.0100    0.0001
   140        0.0119             nan     0.0100    0.0000
   160        0.0106             nan     0.0100    0.0000
   180        0.0093             nan     0.0100    0.0000
   200        0.0084             nan     0.0100   -0.0000

- Fold06: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold06: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0403             nan     0.0500    0.0027
     2        0.0372             nan     0.0500    0.0025
     3        0.0346             nan     0.0500    0.0019
     4        0.0326             nan     0.0500    0.0018
     5        0.0303             nan     0.0500    0.0023
     6        0.0282             nan     0.0500    0.0012
     7        0.0271             nan     0.0500    0.0013
     8        0.0257             nan     0.0500    0.0012
     9        0.0245             nan     0.0500    0.0006
    10        0.0231             nan     0.0500    0.0013
    20        0.0140             nan     0.0500    0.0005
    40        0.0063             nan     0.0500    0.0000
    60        0.0031             nan     0.0500    0.0000
    80        0.0017             nan     0.0500    0.0000
   100        0.0011             nan     0.0500   -0.0000
   120        0.0006             nan     0.0500    0.0000
   140        0.0004             nan     0.0500    0.0000
   160        0.0002             nan     0.0500    0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold06: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold06: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0406             nan     0.0500    0.0016
     2        0.0382             nan     0.0500    0.0014
     3        0.0366             nan     0.0500    0.0002
     4        0.0342             nan     0.0500    0.0026
     5        0.0328             nan     0.0500   -0.0001
     6        0.0316             nan     0.0500    0.0011
     7        0.0293             nan     0.0500    0.0016
     8        0.0276             nan     0.0500    0.0017
     9        0.0263             nan     0.0500    0.0012
    10        0.0257             nan     0.0500   -0.0003
    20        0.0149             nan     0.0500    0.0006
    40        0.0066             nan     0.0500    0.0003
    60        0.0038             nan     0.0500   -0.0001
    80        0.0020             nan     0.0500   -0.0000
   100        0.0011             nan     0.0500   -0.0000
   120        0.0006             nan     0.0500    0.0000
   140        0.0004             nan     0.0500    0.0000
   160        0.0003             nan     0.0500    0.0000
   180        0.0002             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500    0.0000

- Fold06: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold06: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0404             nan     0.0500    0.0027
     2        0.0382             nan     0.0500    0.0013
     3        0.0366             nan     0.0500    0.0008
     4        0.0346             nan     0.0500    0.0021
     5        0.0324             nan     0.0500    0.0020
     6        0.0302             nan     0.0500    0.0020
     7        0.0280             nan     0.0500    0.0017
     8        0.0262             nan     0.0500    0.0013
     9        0.0249             nan     0.0500    0.0011
    10        0.0234             nan     0.0500    0.0014
    20        0.0161             nan     0.0500    0.0002
    40        0.0079             nan     0.0500    0.0003
    60        0.0045             nan     0.0500    0.0000
    80        0.0027             nan     0.0500   -0.0000
   100        0.0019             nan     0.0500   -0.0000
   120        0.0013             nan     0.0500   -0.0000
   140        0.0010             nan     0.0500   -0.0000
   160        0.0007             nan     0.0500   -0.0000
   180        0.0006             nan     0.0500   -0.0000
   200        0.0005             nan     0.0500   -0.0000

- Fold06: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold06: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0414             nan     0.0500   -0.0007
     2        0.0380             nan     0.0500    0.0029
     3        0.0357             nan     0.0500   -0.0002
     4        0.0331             nan     0.0500    0.0015
     5        0.0304             nan     0.0500    0.0027
     6        0.0292             nan     0.0500    0.0007
     7        0.0270             nan     0.0500    0.0008
     8        0.0263             nan     0.0500   -0.0002
     9        0.0245             nan     0.0500    0.0016
    10        0.0227             nan     0.0500    0.0009
    20        0.0125             nan     0.0500    0.0009
    40        0.0040             nan     0.0500   -0.0000
    60        0.0016             nan     0.0500    0.0000
    80        0.0007             nan     0.0500   -0.0000
   100        0.0003             nan     0.0500   -0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0001             nan     0.0500    0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500    0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold06: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold06: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0410             nan     0.0500    0.0018
     2        0.0380             nan     0.0500    0.0021
     3        0.0352             nan     0.0500    0.0011
     4        0.0323             nan     0.0500    0.0028
     5        0.0301             nan     0.0500    0.0021
     6        0.0285             nan     0.0500    0.0019
     7        0.0275             nan     0.0500    0.0001
     8        0.0258             nan     0.0500    0.0015
     9        0.0245             nan     0.0500    0.0014
    10        0.0241             nan     0.0500   -0.0007
    20        0.0127             nan     0.0500   -0.0001
    40        0.0047             nan     0.0500    0.0001
    60        0.0020             nan     0.0500    0.0001
    80        0.0011             nan     0.0500   -0.0000
   100        0.0006             nan     0.0500   -0.0000
   120        0.0003             nan     0.0500    0.0000
   140        0.0002             nan     0.0500    0.0000
   160        0.0001             nan     0.0500    0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold06: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold06: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0416             nan     0.0500    0.0004
     2        0.0386             nan     0.0500    0.0027
     3        0.0369             nan     0.0500   -0.0005
     4        0.0349             nan     0.0500    0.0023
     5        0.0338             nan     0.0500    0.0007
     6        0.0321             nan     0.0500    0.0008
     7        0.0306             nan     0.0500    0.0003
     8        0.0282             nan     0.0500    0.0018
     9        0.0271             nan     0.0500    0.0012
    10        0.0260             nan     0.0500    0.0005
    20        0.0162             nan     0.0500    0.0003
    40        0.0091             nan     0.0500    0.0000
    60        0.0053             nan     0.0500    0.0000
    80        0.0035             nan     0.0500   -0.0000
   100        0.0024             nan     0.0500   -0.0001
   120        0.0019             nan     0.0500   -0.0000
   140        0.0014             nan     0.0500   -0.0001
   160        0.0009             nan     0.0500    0.0000
   180        0.0007             nan     0.0500    0.0000
   200        0.0005             nan     0.0500   -0.0000

- Fold06: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold06: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0396             nan     0.0500    0.0034
     2        0.0369             nan     0.0500    0.0023
     3        0.0346             nan     0.0500    0.0007
     4        0.0330             nan     0.0500    0.0011
     5        0.0318             nan     0.0500    0.0011
     6        0.0287             nan     0.0500    0.0023
     7        0.0280             nan     0.0500   -0.0011
     8        0.0270             nan     0.0500   -0.0006
     9        0.0253             nan     0.0500    0.0015
    10        0.0238             nan     0.0500    0.0008
    20        0.0116             nan     0.0500    0.0008
    40        0.0038             nan     0.0500    0.0002
    60        0.0015             nan     0.0500   -0.0000
    80        0.0006             nan     0.0500   -0.0000
   100        0.0003             nan     0.0500    0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0001             nan     0.0500    0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold06: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold06: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0395             nan     0.0500    0.0030
     2        0.0362             nan     0.0500    0.0028
     3        0.0338             nan     0.0500    0.0005
     4        0.0306             nan     0.0500    0.0019
     5        0.0284             nan     0.0500    0.0015
     6        0.0256             nan     0.0500    0.0019
     7        0.0232             nan     0.0500    0.0012
     8        0.0223             nan     0.0500   -0.0004
     9        0.0210             nan     0.0500    0.0015
    10        0.0201             nan     0.0500    0.0007
    20        0.0117             nan     0.0500    0.0005
    40        0.0041             nan     0.0500    0.0002
    60        0.0019             nan     0.0500    0.0001
    80        0.0010             nan     0.0500   -0.0000
   100        0.0006             nan     0.0500   -0.0000
   120        0.0003             nan     0.0500   -0.0000
   140        0.0002             nan     0.0500   -0.0000
   160        0.0001             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500    0.0000

- Fold06: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold06: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0409             nan     0.0500    0.0013
     2        0.0402             nan     0.0500    0.0002
     3        0.0376             nan     0.0500    0.0025
     4        0.0361             nan     0.0500    0.0016
     5        0.0331             nan     0.0500    0.0017
     6        0.0313             nan     0.0500    0.0012
     7        0.0306             nan     0.0500    0.0001
     8        0.0290             nan     0.0500    0.0009
     9        0.0282             nan     0.0500   -0.0001
    10        0.0268             nan     0.0500    0.0015
    20        0.0171             nan     0.0500    0.0006
    40        0.0087             nan     0.0500    0.0001
    60        0.0050             nan     0.0500   -0.0001
    80        0.0035             nan     0.0500    0.0000
   100        0.0024             nan     0.0500   -0.0000
   120        0.0019             nan     0.0500   -0.0000
   140        0.0013             nan     0.0500   -0.0000
   160        0.0010             nan     0.0500   -0.0000
   180        0.0007             nan     0.0500   -0.0000
   200        0.0005             nan     0.0500    0.0000

- Fold06: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold06: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0383             nan     0.1000    0.0035
     2        0.0336             nan     0.1000    0.0045
     3        0.0299             nan     0.1000    0.0010
     4        0.0286             nan     0.1000    0.0001
     5        0.0279             nan     0.1000   -0.0013
     6        0.0246             nan     0.1000    0.0034
     7        0.0219             nan     0.1000    0.0024
     8        0.0191             nan     0.1000    0.0004
     9        0.0169             nan     0.1000    0.0001
    10        0.0151             nan     0.1000    0.0020
    20        0.0050             nan     0.1000    0.0001
    40        0.0014             nan     0.1000    0.0000
    60        0.0006             nan     0.1000   -0.0000
    80        0.0003             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold06: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold06: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0380             nan     0.1000    0.0053
     2        0.0343             nan     0.1000    0.0019
     3        0.0301             nan     0.1000    0.0039
     4        0.0289             nan     0.1000   -0.0005
     5        0.0250             nan     0.1000    0.0029
     6        0.0222             nan     0.1000    0.0015
     7        0.0204             nan     0.1000    0.0006
     8        0.0181             nan     0.1000    0.0017
     9        0.0173             nan     0.1000    0.0001
    10        0.0160             nan     0.1000    0.0001
    20        0.0080             nan     0.1000    0.0005
    40        0.0023             nan     0.1000   -0.0000
    60        0.0007             nan     0.1000   -0.0000
    80        0.0003             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000    0.0000
   120        0.0001             nan     0.1000    0.0000
   140        0.0000             nan     0.1000    0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold06: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold06: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0391             nan     0.1000    0.0030
     2        0.0342             nan     0.1000    0.0049
     3        0.0312             nan     0.1000    0.0024
     4        0.0267             nan     0.1000    0.0031
     5        0.0233             nan     0.1000    0.0026
     6        0.0224             nan     0.1000    0.0007
     7        0.0202             nan     0.1000    0.0022
     8        0.0171             nan     0.1000    0.0007
     9        0.0161             nan     0.1000    0.0000
    10        0.0143             nan     0.1000    0.0006
    20        0.0071             nan     0.1000    0.0006
    40        0.0028             nan     0.1000   -0.0001
    60        0.0010             nan     0.1000   -0.0001
    80        0.0005             nan     0.1000   -0.0000
   100        0.0003             nan     0.1000   -0.0000
   120        0.0002             nan     0.1000    0.0000
   140        0.0001             nan     0.1000    0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold06: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold06: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0387             nan     0.1000    0.0042
     2        0.0325             nan     0.1000    0.0052
     3        0.0269             nan     0.1000    0.0029
     4        0.0242             nan     0.1000    0.0012
     5        0.0213             nan     0.1000    0.0014
     6        0.0189             nan     0.1000    0.0011
     7        0.0171             nan     0.1000    0.0020
     8        0.0147             nan     0.1000    0.0011
     9        0.0130             nan     0.1000    0.0010
    10        0.0115             nan     0.1000    0.0013
    20        0.0039             nan     0.1000   -0.0001
    40        0.0007             nan     0.1000   -0.0000
    60        0.0002             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000    0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold06: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold06: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0356             nan     0.1000    0.0059
     2        0.0307             nan     0.1000    0.0048
     3        0.0283             nan     0.1000    0.0009
     4        0.0252             nan     0.1000    0.0023
     5        0.0222             nan     0.1000    0.0020
     6        0.0192             nan     0.1000    0.0018
     7        0.0161             nan     0.1000    0.0018
     8        0.0139             nan     0.1000    0.0013
     9        0.0134             nan     0.1000    0.0001
    10        0.0120             nan     0.1000    0.0014
    20        0.0041             nan     0.1000    0.0001
    40        0.0013             nan     0.1000    0.0000
    60        0.0004             nan     0.1000   -0.0000
    80        0.0002             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000    0.0000
   200        0.0000             nan     0.1000    0.0000

- Fold06: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold06: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0407             nan     0.1000   -0.0000
     2        0.0355             nan     0.1000    0.0052
     3        0.0328             nan     0.1000    0.0008
     4        0.0289             nan     0.1000    0.0040
     5        0.0257             nan     0.1000    0.0032
     6        0.0247             nan     0.1000   -0.0010
     7        0.0222             nan     0.1000    0.0021
     8        0.0204             nan     0.1000    0.0012
     9        0.0187             nan     0.1000    0.0015
    10        0.0168             nan     0.1000    0.0015
    20        0.0076             nan     0.1000    0.0004
    40        0.0029             nan     0.1000   -0.0001
    60        0.0015             nan     0.1000    0.0000
    80        0.0007             nan     0.1000   -0.0000
   100        0.0004             nan     0.1000   -0.0000
   120        0.0002             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000    0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold06: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold06: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0385             nan     0.1000    0.0015
     2        0.0315             nan     0.1000    0.0051
     3        0.0267             nan     0.1000    0.0039
     4        0.0218             nan     0.1000    0.0039
     5        0.0186             nan     0.1000    0.0012
     6        0.0168             nan     0.1000    0.0015
     7        0.0151             nan     0.1000    0.0007
     8        0.0135             nan     0.1000    0.0009
     9        0.0116             nan     0.1000    0.0012
    10        0.0100             nan     0.1000    0.0015
    20        0.0034             nan     0.1000    0.0002
    40        0.0006             nan     0.1000   -0.0000
    60        0.0002             nan     0.1000   -0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold06: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold06: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0369             nan     0.1000    0.0059
     2        0.0309             nan     0.1000    0.0056
     3        0.0281             nan     0.1000    0.0026
     4        0.0255             nan     0.1000    0.0012
     5        0.0228             nan     0.1000    0.0009
     6        0.0211             nan     0.1000    0.0009
     7        0.0194             nan     0.1000   -0.0004
     8        0.0181             nan     0.1000    0.0008
     9        0.0154             nan     0.1000    0.0014
    10        0.0136             nan     0.1000    0.0013
    20        0.0051             nan     0.1000    0.0001
    40        0.0018             nan     0.1000   -0.0001
    60        0.0006             nan     0.1000   -0.0000
    80        0.0004             nan     0.1000   -0.0000
   100        0.0002             nan     0.1000   -0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold06: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold06: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0379             nan     0.1000    0.0040
     2        0.0338             nan     0.1000    0.0032
     3        0.0295             nan     0.1000    0.0039
     4        0.0266             nan     0.1000    0.0022
     5        0.0234             nan     0.1000    0.0025
     6        0.0204             nan     0.1000    0.0025
     7        0.0192             nan     0.1000    0.0006
     8        0.0169             nan     0.1000    0.0010
     9        0.0152             nan     0.1000    0.0012
    10        0.0142             nan     0.1000    0.0001
    20        0.0076             nan     0.1000   -0.0004
    40        0.0029             nan     0.1000    0.0001
    60        0.0016             nan     0.1000    0.0000
    80        0.0009             nan     0.1000   -0.0000
   100        0.0005             nan     0.1000   -0.0000
   120        0.0003             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0002             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000    0.0000

- Fold06: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold07: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0424             nan     0.0100    0.0004
     2        0.0418             nan     0.0100    0.0006
     3        0.0412             nan     0.0100    0.0006
     4        0.0408             nan     0.0100    0.0001
     5        0.0403             nan     0.0100    0.0005
     6        0.0398             nan     0.0100    0.0005
     7        0.0393             nan     0.0100    0.0004
     8        0.0388             nan     0.0100    0.0003
     9        0.0383             nan     0.0100    0.0003
    10        0.0378             nan     0.0100    0.0005
    20        0.0336             nan     0.0100    0.0002
    40        0.0269             nan     0.0100    0.0003
    60        0.0219             nan     0.0100    0.0002
    80        0.0178             nan     0.0100    0.0002
   100        0.0146             nan     0.0100    0.0001
   120        0.0120             nan     0.0100    0.0001
   140        0.0103             nan     0.0100    0.0000
   160        0.0085             nan     0.0100    0.0000
   180        0.0072             nan     0.0100    0.0000
   200        0.0061             nan     0.0100    0.0000

- Fold07: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold07: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0424             nan     0.0100    0.0004
     2        0.0419             nan     0.0100    0.0006
     3        0.0413             nan     0.0100    0.0006
     4        0.0407             nan     0.0100    0.0005
     5        0.0403             nan     0.0100    0.0004
     6        0.0400             nan     0.0100    0.0005
     7        0.0395             nan     0.0100    0.0003
     8        0.0392             nan     0.0100   -0.0000
     9        0.0389             nan     0.0100    0.0003
    10        0.0387             nan     0.0100   -0.0000
    20        0.0346             nan     0.0100    0.0003
    40        0.0277             nan     0.0100   -0.0000
    60        0.0226             nan     0.0100    0.0001
    80        0.0189             nan     0.0100    0.0002
   100        0.0157             nan     0.0100    0.0001
   120        0.0129             nan     0.0100    0.0002
   140        0.0107             nan     0.0100    0.0001
   160        0.0090             nan     0.0100    0.0000
   180        0.0077             nan     0.0100    0.0000
   200        0.0065             nan     0.0100    0.0001

- Fold07: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold07: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0424             nan     0.0100    0.0005
     2        0.0419             nan     0.0100    0.0004
     3        0.0415             nan     0.0100    0.0005
     4        0.0410             nan     0.0100    0.0004
     5        0.0404             nan     0.0100    0.0003
     6        0.0399             nan     0.0100    0.0005
     7        0.0394             nan     0.0100    0.0005
     8        0.0388             nan     0.0100    0.0002
     9        0.0383             nan     0.0100    0.0003
    10        0.0380             nan     0.0100    0.0000
    20        0.0334             nan     0.0100    0.0003
    40        0.0268             nan     0.0100    0.0002
    60        0.0219             nan     0.0100    0.0002
    80        0.0181             nan     0.0100    0.0001
   100        0.0155             nan     0.0100    0.0001
   120        0.0131             nan     0.0100    0.0001
   140        0.0111             nan     0.0100    0.0001
   160        0.0099             nan     0.0100    0.0000
   180        0.0089             nan     0.0100    0.0000
   200        0.0079             nan     0.0100   -0.0000

- Fold07: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold07: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0422             nan     0.0100    0.0006
     2        0.0414             nan     0.0100    0.0009
     3        0.0408             nan     0.0100    0.0005
     4        0.0401             nan     0.0100    0.0006
     5        0.0396             nan     0.0100    0.0003
     6        0.0390             nan     0.0100    0.0003
     7        0.0385             nan     0.0100    0.0005
     8        0.0381             nan     0.0100    0.0001
     9        0.0374             nan     0.0100    0.0006
    10        0.0367             nan     0.0100    0.0006
    20        0.0318             nan     0.0100    0.0003
    40        0.0245             nan     0.0100    0.0001
    60        0.0192             nan     0.0100    0.0001
    80        0.0145             nan     0.0100    0.0001
   100        0.0116             nan     0.0100    0.0002
   120        0.0093             nan     0.0100    0.0001
   140        0.0075             nan     0.0100    0.0000
   160        0.0060             nan     0.0100    0.0000
   180        0.0048             nan     0.0100    0.0000
   200        0.0038             nan     0.0100    0.0000

- Fold07: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold07: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0424             nan     0.0100    0.0003
     2        0.0417             nan     0.0100    0.0005
     3        0.0411             nan     0.0100    0.0006
     4        0.0405             nan     0.0100    0.0003
     5        0.0398             nan     0.0100    0.0006
     6        0.0390             nan     0.0100    0.0006
     7        0.0385             nan     0.0100   -0.0000
     8        0.0380             nan     0.0100    0.0006
     9        0.0375             nan     0.0100    0.0004
    10        0.0369             nan     0.0100    0.0004
    20        0.0323             nan     0.0100    0.0002
    40        0.0245             nan     0.0100    0.0001
    60        0.0189             nan     0.0100    0.0002
    80        0.0148             nan     0.0100    0.0001
   100        0.0115             nan     0.0100    0.0002
   120        0.0092             nan     0.0100    0.0001
   140        0.0075             nan     0.0100    0.0000
   160        0.0062             nan     0.0100    0.0000
   180        0.0051             nan     0.0100    0.0000
   200        0.0042             nan     0.0100    0.0000

- Fold07: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold07: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0425             nan     0.0100    0.0004
     2        0.0419             nan     0.0100    0.0005
     3        0.0414             nan     0.0100    0.0004
     4        0.0410             nan     0.0100    0.0003
     5        0.0405             nan     0.0100    0.0005
     6        0.0400             nan     0.0100    0.0005
     7        0.0396             nan     0.0100    0.0005
     8        0.0391             nan     0.0100    0.0002
     9        0.0385             nan     0.0100    0.0005
    10        0.0379             nan     0.0100    0.0005
    20        0.0337             nan     0.0100    0.0003
    40        0.0273             nan     0.0100   -0.0000
    60        0.0231             nan     0.0100   -0.0000
    80        0.0193             nan     0.0100    0.0002
   100        0.0164             nan     0.0100    0.0001
   120        0.0139             nan     0.0100    0.0001
   140        0.0120             nan     0.0100    0.0000
   160        0.0105             nan     0.0100   -0.0000
   180        0.0093             nan     0.0100    0.0000
   200        0.0082             nan     0.0100    0.0000

- Fold07: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold07: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0422             nan     0.0100    0.0005
     2        0.0417             nan     0.0100    0.0001
     3        0.0413             nan     0.0100    0.0002
     4        0.0407             nan     0.0100    0.0005
     5        0.0400             nan     0.0100    0.0003
     6        0.0395             nan     0.0100    0.0002
     7        0.0386             nan     0.0100    0.0005
     8        0.0382             nan     0.0100    0.0003
     9        0.0376             nan     0.0100    0.0006
    10        0.0371             nan     0.0100    0.0003
    20        0.0323             nan     0.0100    0.0004
    40        0.0243             nan     0.0100    0.0002
    60        0.0182             nan     0.0100    0.0003
    80        0.0138             nan     0.0100    0.0001
   100        0.0104             nan     0.0100    0.0002
   120        0.0081             nan     0.0100    0.0000
   140        0.0061             nan     0.0100    0.0001
   160        0.0048             nan     0.0100    0.0000
   180        0.0038             nan     0.0100    0.0000
   200        0.0032             nan     0.0100    0.0000

- Fold07: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold07: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0424             nan     0.0100    0.0004
     2        0.0418             nan     0.0100    0.0006
     3        0.0414             nan     0.0100    0.0004
     4        0.0407             nan     0.0100    0.0006
     5        0.0400             nan     0.0100    0.0006
     6        0.0392             nan     0.0100    0.0005
     7        0.0387             nan     0.0100    0.0005
     8        0.0383             nan     0.0100    0.0005
     9        0.0380             nan     0.0100    0.0000
    10        0.0375             nan     0.0100    0.0001
    20        0.0322             nan     0.0100    0.0002
    40        0.0249             nan     0.0100    0.0002
    60        0.0195             nan     0.0100   -0.0000
    80        0.0152             nan     0.0100    0.0001
   100        0.0115             nan     0.0100    0.0002
   120        0.0092             nan     0.0100    0.0000
   140        0.0076             nan     0.0100    0.0001
   160        0.0061             nan     0.0100   -0.0000
   180        0.0048             nan     0.0100    0.0000
   200        0.0039             nan     0.0100    0.0000

- Fold07: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold07: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0425             nan     0.0100    0.0004
     2        0.0419             nan     0.0100    0.0002
     3        0.0414             nan     0.0100    0.0003
     4        0.0409             nan     0.0100    0.0002
     5        0.0403             nan     0.0100    0.0005
     6        0.0398             nan     0.0100    0.0003
     7        0.0394             nan     0.0100    0.0005
     8        0.0390             nan     0.0100    0.0001
     9        0.0386             nan     0.0100    0.0003
    10        0.0382             nan     0.0100    0.0001
    20        0.0341             nan     0.0100    0.0003
    40        0.0279             nan     0.0100    0.0001
    60        0.0226             nan     0.0100    0.0001
    80        0.0186             nan     0.0100    0.0002
   100        0.0155             nan     0.0100    0.0001
   120        0.0135             nan     0.0100    0.0000
   140        0.0118             nan     0.0100   -0.0000
   160        0.0106             nan     0.0100    0.0001
   180        0.0092             nan     0.0100    0.0000
   200        0.0082             nan     0.0100   -0.0000

- Fold07: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold07: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0418             nan     0.0500    0.0009
     2        0.0395             nan     0.0500    0.0017
     3        0.0376             nan     0.0500    0.0011
     4        0.0356             nan     0.0500    0.0015
     5        0.0331             nan     0.0500    0.0021
     6        0.0313             nan     0.0500    0.0016
     7        0.0300             nan     0.0500    0.0008
     8        0.0284             nan     0.0500    0.0012
     9        0.0268             nan     0.0500    0.0016
    10        0.0249             nan     0.0500    0.0012
    20        0.0152             nan     0.0500    0.0008
    40        0.0071             nan     0.0500    0.0003
    60        0.0036             nan     0.0500    0.0000
    80        0.0016             nan     0.0500    0.0001
   100        0.0009             nan     0.0500    0.0000
   120        0.0006             nan     0.0500   -0.0000
   140        0.0004             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500    0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold07: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold07: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0408             nan     0.0500    0.0018
     2        0.0382             nan     0.0500    0.0024
     3        0.0369             nan     0.0500    0.0010
     4        0.0344             nan     0.0500    0.0020
     5        0.0324             nan     0.0500    0.0019
     6        0.0312             nan     0.0500    0.0016
     7        0.0303             nan     0.0500   -0.0001
     8        0.0284             nan     0.0500    0.0018
     9        0.0267             nan     0.0500    0.0003
    10        0.0253             nan     0.0500    0.0016
    20        0.0142             nan     0.0500    0.0009
    40        0.0061             nan     0.0500    0.0002
    60        0.0029             nan     0.0500    0.0000
    80        0.0016             nan     0.0500   -0.0000
   100        0.0010             nan     0.0500    0.0000
   120        0.0007             nan     0.0500   -0.0000
   140        0.0004             nan     0.0500    0.0000
   160        0.0003             nan     0.0500   -0.0000
   180        0.0002             nan     0.0500    0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold07: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold07: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0405             nan     0.0500    0.0013
     2        0.0378             nan     0.0500    0.0017
     3        0.0358             nan     0.0500    0.0011
     4        0.0336             nan     0.0500    0.0006
     5        0.0317             nan     0.0500    0.0020
     6        0.0297             nan     0.0500    0.0018
     7        0.0278             nan     0.0500    0.0019
     8        0.0262             nan     0.0500    0.0010
     9        0.0253             nan     0.0500    0.0005
    10        0.0239             nan     0.0500    0.0013
    20        0.0150             nan     0.0500    0.0006
    40        0.0085             nan     0.0500    0.0000
    60        0.0049             nan     0.0500    0.0001
    80        0.0030             nan     0.0500    0.0001
   100        0.0024             nan     0.0500   -0.0000
   120        0.0017             nan     0.0500    0.0000
   140        0.0012             nan     0.0500   -0.0000
   160        0.0009             nan     0.0500   -0.0000
   180        0.0007             nan     0.0500    0.0000
   200        0.0005             nan     0.0500   -0.0000

- Fold07: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold07: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0399             nan     0.0500    0.0024
     2        0.0368             nan     0.0500    0.0030
     3        0.0338             nan     0.0500    0.0025
     4        0.0307             nan     0.0500    0.0012
     5        0.0284             nan     0.0500    0.0024
     6        0.0261             nan     0.0500    0.0010
     7        0.0244             nan     0.0500    0.0013
     8        0.0228             nan     0.0500    0.0013
     9        0.0217             nan     0.0500    0.0008
    10        0.0208             nan     0.0500    0.0003
    20        0.0115             nan     0.0500    0.0001
    40        0.0037             nan     0.0500    0.0001
    60        0.0015             nan     0.0500   -0.0000
    80        0.0006             nan     0.0500   -0.0000
   100        0.0003             nan     0.0500   -0.0000
   120        0.0001             nan     0.0500    0.0000
   140        0.0001             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold07: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold07: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0404             nan     0.0500    0.0019
     2        0.0375             nan     0.0500    0.0027
     3        0.0359             nan     0.0500    0.0009
     4        0.0332             nan     0.0500    0.0020
     5        0.0326             nan     0.0500   -0.0011
     6        0.0308             nan     0.0500    0.0016
     7        0.0297             nan     0.0500    0.0005
     8        0.0287             nan     0.0500    0.0004
     9        0.0269             nan     0.0500    0.0004
    10        0.0253             nan     0.0500    0.0005
    20        0.0131             nan     0.0500    0.0004
    40        0.0054             nan     0.0500    0.0002
    60        0.0022             nan     0.0500    0.0001
    80        0.0013             nan     0.0500   -0.0000
   100        0.0008             nan     0.0500    0.0000
   120        0.0005             nan     0.0500    0.0000
   140        0.0003             nan     0.0500    0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold07: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold07: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0412             nan     0.0500    0.0017
     2        0.0386             nan     0.0500    0.0028
     3        0.0361             nan     0.0500    0.0022
     4        0.0356             nan     0.0500   -0.0008
     5        0.0335             nan     0.0500    0.0008
     6        0.0321             nan     0.0500    0.0017
     7        0.0304             nan     0.0500    0.0018
     8        0.0285             nan     0.0500    0.0018
     9        0.0269             nan     0.0500    0.0012
    10        0.0256             nan     0.0500    0.0014
    20        0.0163             nan     0.0500    0.0003
    40        0.0082             nan     0.0500    0.0003
    60        0.0049             nan     0.0500    0.0000
    80        0.0034             nan     0.0500    0.0001
   100        0.0021             nan     0.0500   -0.0000
   120        0.0015             nan     0.0500    0.0000
   140        0.0011             nan     0.0500   -0.0000
   160        0.0009             nan     0.0500   -0.0000
   180        0.0007             nan     0.0500   -0.0000
   200        0.0005             nan     0.0500   -0.0000

- Fold07: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold07: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0396             nan     0.0500    0.0030
     2        0.0375             nan     0.0500    0.0009
     3        0.0343             nan     0.0500    0.0026
     4        0.0331             nan     0.0500    0.0013
     5        0.0299             nan     0.0500    0.0036
     6        0.0276             nan     0.0500    0.0020
     7        0.0268             nan     0.0500   -0.0004
     8        0.0257             nan     0.0500    0.0005
     9        0.0241             nan     0.0500    0.0005
    10        0.0221             nan     0.0500    0.0011
    20        0.0105             nan     0.0500    0.0001
    40        0.0035             nan     0.0500    0.0002
    60        0.0013             nan     0.0500   -0.0001
    80        0.0006             nan     0.0500    0.0000
   100        0.0002             nan     0.0500   -0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0000             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold07: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold07: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0392             nan     0.0500    0.0025
     2        0.0359             nan     0.0500    0.0019
     3        0.0335             nan     0.0500    0.0024
     4        0.0307             nan     0.0500    0.0018
     5        0.0280             nan     0.0500    0.0009
     6        0.0263             nan     0.0500    0.0015
     7        0.0243             nan     0.0500    0.0015
     8        0.0234             nan     0.0500    0.0002
     9        0.0222             nan     0.0500    0.0010
    10        0.0203             nan     0.0500    0.0009
    20        0.0102             nan     0.0500    0.0007
    40        0.0036             nan     0.0500    0.0001
    60        0.0018             nan     0.0500   -0.0000
    80        0.0010             nan     0.0500    0.0000
   100        0.0005             nan     0.0500   -0.0000
   120        0.0003             nan     0.0500   -0.0000
   140        0.0002             nan     0.0500   -0.0000
   160        0.0001             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500    0.0000

- Fold07: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold07: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0403             nan     0.0500    0.0020
     2        0.0377             nan     0.0500    0.0028
     3        0.0353             nan     0.0500    0.0015
     4        0.0335             nan     0.0500    0.0002
     5        0.0322             nan     0.0500    0.0001
     6        0.0299             nan     0.0500    0.0020
     7        0.0287             nan     0.0500   -0.0003
     8        0.0272             nan     0.0500    0.0015
     9        0.0256             nan     0.0500    0.0015
    10        0.0248             nan     0.0500    0.0000
    20        0.0155             nan     0.0500    0.0005
    40        0.0082             nan     0.0500    0.0002
    60        0.0050             nan     0.0500    0.0001
    80        0.0033             nan     0.0500   -0.0001
   100        0.0021             nan     0.0500   -0.0000
   120        0.0017             nan     0.0500    0.0000
   140        0.0012             nan     0.0500    0.0000
   160        0.0009             nan     0.0500   -0.0000
   180        0.0007             nan     0.0500    0.0000
   200        0.0006             nan     0.0500   -0.0000

- Fold07: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold07: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0381             nan     0.1000    0.0055
     2        0.0330             nan     0.1000    0.0040
     3        0.0298             nan     0.1000    0.0021
     4        0.0269             nan     0.1000    0.0019
     5        0.0242             nan     0.1000    0.0006
     6        0.0218             nan     0.1000    0.0020
     7        0.0203             nan     0.1000   -0.0001
     8        0.0185             nan     0.1000    0.0013
     9        0.0167             nan     0.1000    0.0014
    10        0.0155             nan     0.1000    0.0014
    20        0.0066             nan     0.1000    0.0003
    40        0.0018             nan     0.1000    0.0000
    60        0.0006             nan     0.1000    0.0000
    80        0.0002             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000    0.0000
   120        0.0000             nan     0.1000    0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold07: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold07: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0385             nan     0.1000    0.0040
     2        0.0338             nan     0.1000    0.0019
     3        0.0303             nan     0.1000    0.0039
     4        0.0259             nan     0.1000    0.0033
     5        0.0251             nan     0.1000   -0.0004
     6        0.0225             nan     0.1000    0.0030
     7        0.0198             nan     0.1000    0.0014
     8        0.0179             nan     0.1000   -0.0003
     9        0.0161             nan     0.1000    0.0019
    10        0.0141             nan     0.1000    0.0016
    20        0.0060             nan     0.1000    0.0004
    40        0.0016             nan     0.1000   -0.0000
    60        0.0007             nan     0.1000   -0.0000
    80        0.0003             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000    0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000    0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold07: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold07: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0379             nan     0.1000    0.0050
     2        0.0347             nan     0.1000    0.0032
     3        0.0312             nan     0.1000    0.0031
     4        0.0277             nan     0.1000    0.0017
     5        0.0249             nan     0.1000    0.0013
     6        0.0226             nan     0.1000    0.0021
     7        0.0204             nan     0.1000    0.0017
     8        0.0183             nan     0.1000    0.0023
     9        0.0165             nan     0.1000    0.0005
    10        0.0150             nan     0.1000    0.0016
    20        0.0075             nan     0.1000   -0.0003
    40        0.0033             nan     0.1000    0.0000
    60        0.0017             nan     0.1000   -0.0001
    80        0.0010             nan     0.1000   -0.0001
   100        0.0006             nan     0.1000   -0.0000
   120        0.0004             nan     0.1000    0.0000
   140        0.0002             nan     0.1000    0.0000
   160        0.0002             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000    0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold07: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold07: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0363             nan     0.1000    0.0054
     2        0.0310             nan     0.1000    0.0055
     3        0.0288             nan     0.1000    0.0019
     4        0.0262             nan     0.1000    0.0011
     5        0.0235             nan     0.1000    0.0010
     6        0.0208             nan     0.1000    0.0019
     7        0.0181             nan     0.1000    0.0018
     8        0.0152             nan     0.1000    0.0016
     9        0.0139             nan     0.1000    0.0005
    10        0.0122             nan     0.1000    0.0007
    20        0.0034             nan     0.1000    0.0001
    40        0.0005             nan     0.1000   -0.0000
    60        0.0001             nan     0.1000    0.0000
    80        0.0000             nan     0.1000    0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000    0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000    0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold07: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold07: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0369             nan     0.1000    0.0059
     2        0.0337             nan     0.1000    0.0038
     3        0.0321             nan     0.1000   -0.0004
     4        0.0278             nan     0.1000    0.0033
     5        0.0244             nan     0.1000    0.0034
     6        0.0225             nan     0.1000    0.0020
     7        0.0201             nan     0.1000    0.0023
     8        0.0178             nan     0.1000    0.0020
     9        0.0163             nan     0.1000    0.0013
    10        0.0139             nan     0.1000    0.0010
    20        0.0057             nan     0.1000   -0.0001
    40        0.0012             nan     0.1000   -0.0000
    60        0.0004             nan     0.1000    0.0000
    80        0.0002             nan     0.1000    0.0000
   100        0.0001             nan     0.1000    0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold07: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold07: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0377             nan     0.1000    0.0037
     2        0.0342             nan     0.1000    0.0026
     3        0.0321             nan     0.1000    0.0018
     4        0.0289             nan     0.1000    0.0023
     5        0.0252             nan     0.1000    0.0034
     6        0.0237             nan     0.1000    0.0005
     7        0.0220             nan     0.1000    0.0010
     8        0.0202             nan     0.1000    0.0008
     9        0.0186             nan     0.1000    0.0009
    10        0.0170             nan     0.1000    0.0001
    20        0.0079             nan     0.1000    0.0003
    40        0.0029             nan     0.1000    0.0000
    60        0.0016             nan     0.1000    0.0000
    80        0.0008             nan     0.1000    0.0000
   100        0.0004             nan     0.1000    0.0000
   120        0.0002             nan     0.1000    0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold07: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold07: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0369             nan     0.1000    0.0011
     2        0.0315             nan     0.1000    0.0048
     3        0.0286             nan     0.1000    0.0030
     4        0.0235             nan     0.1000    0.0029
     5        0.0211             nan     0.1000    0.0002
     6        0.0184             nan     0.1000    0.0028
     7        0.0167             nan     0.1000    0.0008
     8        0.0152             nan     0.1000    0.0013
     9        0.0138             nan     0.1000    0.0006
    10        0.0120             nan     0.1000    0.0002
    20        0.0028             nan     0.1000    0.0003
    40        0.0005             nan     0.1000   -0.0000
    60        0.0001             nan     0.1000    0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000    0.0000
   140        0.0000             nan     0.1000    0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold07: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold07: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0362             nan     0.1000    0.0073
     2        0.0290             nan     0.1000    0.0046
     3        0.0254             nan     0.1000    0.0023
     4        0.0208             nan     0.1000    0.0031
     5        0.0182             nan     0.1000    0.0028
     6        0.0170             nan     0.1000    0.0002
     7        0.0141             nan     0.1000    0.0019
     8        0.0122             nan     0.1000    0.0013
     9        0.0105             nan     0.1000    0.0013
    10        0.0091             nan     0.1000    0.0010
    20        0.0035             nan     0.1000    0.0001
    40        0.0009             nan     0.1000   -0.0000
    60        0.0003             nan     0.1000   -0.0000
    80        0.0002             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000    0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000    0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold07: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold07: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0419             nan     0.1000   -0.0023
     2        0.0360             nan     0.1000    0.0055
     3        0.0314             nan     0.1000    0.0039
     4        0.0282             nan     0.1000    0.0033
     5        0.0262             nan     0.1000    0.0016
     6        0.0250             nan     0.1000    0.0008
     7        0.0236             nan     0.1000    0.0012
     8        0.0213             nan     0.1000    0.0014
     9        0.0188             nan     0.1000    0.0020
    10        0.0182             nan     0.1000    0.0004
    20        0.0099             nan     0.1000   -0.0001
    40        0.0034             nan     0.1000    0.0001
    60        0.0014             nan     0.1000   -0.0000
    80        0.0008             nan     0.1000    0.0000
   100        0.0005             nan     0.1000    0.0000
   120        0.0003             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000    0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold07: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold08: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0437             nan     0.0100    0.0005
     2        0.0433             nan     0.0100    0.0005
     3        0.0428             nan     0.0100    0.0004
     4        0.0422             nan     0.0100    0.0006
     5        0.0418             nan     0.0100    0.0002
     6        0.0412             nan     0.0100    0.0004
     7        0.0408             nan     0.0100    0.0006
     8        0.0402             nan     0.0100    0.0004
     9        0.0398             nan     0.0100    0.0004
    10        0.0393             nan     0.0100    0.0006
    20        0.0350             nan     0.0100    0.0004
    40        0.0274             nan     0.0100    0.0002
    60        0.0216             nan     0.0100    0.0002
    80        0.0176             nan     0.0100    0.0002
   100        0.0142             nan     0.0100    0.0001
   120        0.0117             nan     0.0100   -0.0000
   140        0.0097             nan     0.0100    0.0001
   160        0.0082             nan     0.0100    0.0000
   180        0.0069             nan     0.0100    0.0001
   200        0.0057             nan     0.0100    0.0001

- Fold08: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold08: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0440             nan     0.0100    0.0004
     2        0.0435             nan     0.0100    0.0006
     3        0.0429             nan     0.0100    0.0006
     4        0.0423             nan     0.0100    0.0004
     5        0.0420             nan     0.0100   -0.0001
     6        0.0415             nan     0.0100    0.0003
     7        0.0409             nan     0.0100    0.0006
     8        0.0406             nan     0.0100    0.0001
     9        0.0400             nan     0.0100    0.0005
    10        0.0395             nan     0.0100    0.0004
    20        0.0349             nan     0.0100    0.0006
    40        0.0279             nan     0.0100    0.0002
    60        0.0225             nan     0.0100    0.0002
    80        0.0184             nan     0.0100    0.0001
   100        0.0155             nan     0.0100    0.0001
   120        0.0131             nan     0.0100   -0.0001
   140        0.0109             nan     0.0100    0.0000
   160        0.0092             nan     0.0100    0.0000
   180        0.0078             nan     0.0100    0.0000
   200        0.0067             nan     0.0100    0.0000

- Fold08: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold08: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0437             nan     0.0100    0.0007
     2        0.0430             nan     0.0100    0.0006
     3        0.0425             nan     0.0100    0.0006
     4        0.0418             nan     0.0100    0.0006
     5        0.0413             nan     0.0100    0.0006
     6        0.0406             nan     0.0100    0.0006
     7        0.0402             nan     0.0100    0.0000
     8        0.0396             nan     0.0100    0.0006
     9        0.0391             nan     0.0100    0.0004
    10        0.0387             nan     0.0100    0.0003
    20        0.0348             nan     0.0100    0.0004
    40        0.0279             nan     0.0100    0.0004
    60        0.0225             nan     0.0100    0.0001
    80        0.0188             nan     0.0100    0.0001
   100        0.0157             nan     0.0100    0.0001
   120        0.0136             nan     0.0100    0.0000
   140        0.0120             nan     0.0100    0.0000
   160        0.0106             nan     0.0100    0.0001
   180        0.0092             nan     0.0100    0.0001
   200        0.0083             nan     0.0100   -0.0000

- Fold08: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold08: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0438             nan     0.0100    0.0006
     2        0.0434             nan     0.0100    0.0002
     3        0.0429             nan     0.0100    0.0003
     4        0.0419             nan     0.0100    0.0009
     5        0.0414             nan     0.0100    0.0005
     6        0.0407             nan     0.0100    0.0004
     7        0.0401             nan     0.0100    0.0007
     8        0.0394             nan     0.0100    0.0005
     9        0.0388             nan     0.0100    0.0002
    10        0.0384             nan     0.0100    0.0001
    20        0.0334             nan     0.0100    0.0004
    40        0.0246             nan     0.0100    0.0000
    60        0.0188             nan     0.0100   -0.0000
    80        0.0146             nan     0.0100    0.0001
   100        0.0112             nan     0.0100    0.0001
   120        0.0089             nan     0.0100    0.0001
   140        0.0070             nan     0.0100    0.0001
   160        0.0055             nan     0.0100    0.0000
   180        0.0046             nan     0.0100    0.0000
   200        0.0037             nan     0.0100    0.0000

- Fold08: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold08: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0438             nan     0.0100    0.0006
     2        0.0431             nan     0.0100    0.0007
     3        0.0424             nan     0.0100    0.0006
     4        0.0418             nan     0.0100    0.0006
     5        0.0411             nan     0.0100    0.0004
     6        0.0405             nan     0.0100    0.0005
     7        0.0399             nan     0.0100    0.0006
     8        0.0393             nan     0.0100    0.0005
     9        0.0388             nan     0.0100    0.0005
    10        0.0383             nan     0.0100    0.0002
    20        0.0330             nan     0.0100    0.0004
    40        0.0254             nan     0.0100    0.0003
    60        0.0194             nan     0.0100    0.0003
    80        0.0153             nan     0.0100    0.0001
   100        0.0122             nan     0.0100    0.0001
   120        0.0097             nan     0.0100   -0.0000
   140        0.0077             nan     0.0100    0.0000
   160        0.0062             nan     0.0100    0.0001
   180        0.0050             nan     0.0100    0.0000
   200        0.0041             nan     0.0100    0.0000

- Fold08: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold08: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0439             nan     0.0100    0.0005
     2        0.0435             nan     0.0100    0.0005
     3        0.0429             nan     0.0100    0.0006
     4        0.0425             nan     0.0100    0.0003
     5        0.0421             nan     0.0100    0.0003
     6        0.0416             nan     0.0100    0.0006
     7        0.0410             nan     0.0100    0.0003
     8        0.0406             nan     0.0100    0.0003
     9        0.0403             nan     0.0100    0.0003
    10        0.0398             nan     0.0100    0.0005
    20        0.0357             nan     0.0100    0.0004
    40        0.0284             nan     0.0100    0.0000
    60        0.0230             nan     0.0100    0.0002
    80        0.0191             nan     0.0100    0.0002
   100        0.0163             nan     0.0100    0.0001
   120        0.0138             nan     0.0100    0.0001
   140        0.0119             nan     0.0100    0.0000
   160        0.0103             nan     0.0100    0.0000
   180        0.0091             nan     0.0100   -0.0000
   200        0.0082             nan     0.0100    0.0000

- Fold08: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold08: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0437             nan     0.0100    0.0007
     2        0.0431             nan     0.0100    0.0003
     3        0.0427             nan     0.0100    0.0001
     4        0.0420             nan     0.0100    0.0007
     5        0.0412             nan     0.0100    0.0006
     6        0.0403             nan     0.0100    0.0008
     7        0.0400             nan     0.0100    0.0001
     8        0.0395             nan     0.0100    0.0005
     9        0.0388             nan     0.0100    0.0005
    10        0.0381             nan     0.0100    0.0006
    20        0.0331             nan     0.0100    0.0005
    40        0.0249             nan     0.0100    0.0004
    60        0.0182             nan     0.0100    0.0001
    80        0.0140             nan     0.0100    0.0001
   100        0.0108             nan     0.0100    0.0001
   120        0.0082             nan     0.0100    0.0001
   140        0.0064             nan     0.0100    0.0001
   160        0.0051             nan     0.0100    0.0000
   180        0.0040             nan     0.0100    0.0000
   200        0.0032             nan     0.0100    0.0000

- Fold08: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold08: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0438             nan     0.0100    0.0002
     2        0.0431             nan     0.0100    0.0007
     3        0.0425             nan     0.0100    0.0003
     4        0.0418             nan     0.0100    0.0008
     5        0.0412             nan     0.0100    0.0006
     6        0.0405             nan     0.0100    0.0006
     7        0.0399             nan     0.0100    0.0005
     8        0.0394             nan     0.0100    0.0005
     9        0.0390             nan     0.0100    0.0004
    10        0.0383             nan     0.0100    0.0007
    20        0.0329             nan     0.0100    0.0004
    40        0.0251             nan     0.0100    0.0002
    60        0.0194             nan     0.0100    0.0001
    80        0.0151             nan     0.0100    0.0001
   100        0.0117             nan     0.0100    0.0001
   120        0.0093             nan     0.0100    0.0001
   140        0.0074             nan     0.0100    0.0000
   160        0.0059             nan     0.0100    0.0000
   180        0.0048             nan     0.0100    0.0000
   200        0.0040             nan     0.0100   -0.0000

- Fold08: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold08: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0443             nan     0.0100   -0.0003
     2        0.0437             nan     0.0100    0.0004
     3        0.0430             nan     0.0100    0.0005
     4        0.0424             nan     0.0100    0.0006
     5        0.0417             nan     0.0100    0.0006
     6        0.0412             nan     0.0100    0.0006
     7        0.0407             nan     0.0100    0.0004
     8        0.0400             nan     0.0100    0.0004
     9        0.0394             nan     0.0100    0.0006
    10        0.0390             nan     0.0100    0.0003
    20        0.0347             nan     0.0100    0.0004
    40        0.0274             nan     0.0100    0.0002
    60        0.0225             nan     0.0100    0.0003
    80        0.0188             nan     0.0100    0.0002
   100        0.0157             nan     0.0100    0.0001
   120        0.0133             nan     0.0100    0.0000
   140        0.0114             nan     0.0100    0.0000
   160        0.0100             nan     0.0100    0.0001
   180        0.0087             nan     0.0100    0.0000
   200        0.0078             nan     0.0100    0.0000

- Fold08: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold08: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0414             nan     0.0500    0.0028
     2        0.0388             nan     0.0500    0.0023
     3        0.0372             nan     0.0500    0.0010
     4        0.0353             nan     0.0500    0.0014
     5        0.0334             nan     0.0500    0.0017
     6        0.0312             nan     0.0500    0.0020
     7        0.0303             nan     0.0500   -0.0003
     8        0.0281             nan     0.0500    0.0020
     9        0.0264             nan     0.0500    0.0017
    10        0.0258             nan     0.0500    0.0000
    20        0.0144             nan     0.0500    0.0000
    40        0.0058             nan     0.0500    0.0002
    60        0.0029             nan     0.0500    0.0001
    80        0.0016             nan     0.0500   -0.0001
   100        0.0008             nan     0.0500    0.0000
   120        0.0005             nan     0.0500    0.0000
   140        0.0003             nan     0.0500    0.0000
   160        0.0002             nan     0.0500    0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold08: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold08: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0413             nan     0.0500    0.0034
     2        0.0388             nan     0.0500    0.0024
     3        0.0360             nan     0.0500    0.0026
     4        0.0334             nan     0.0500    0.0024
     5        0.0313             nan     0.0500    0.0020
     6        0.0295             nan     0.0500    0.0014
     7        0.0275             nan     0.0500    0.0020
     8        0.0263             nan     0.0500    0.0003
     9        0.0248             nan     0.0500    0.0016
    10        0.0236             nan     0.0500    0.0013
    20        0.0138             nan     0.0500    0.0008
    40        0.0064             nan     0.0500    0.0003
    60        0.0033             nan     0.0500    0.0001
    80        0.0021             nan     0.0500   -0.0000
   100        0.0013             nan     0.0500   -0.0000
   120        0.0008             nan     0.0500   -0.0000
   140        0.0006             nan     0.0500    0.0000
   160        0.0004             nan     0.0500   -0.0000
   180        0.0002             nan     0.0500    0.0000
   200        0.0002             nan     0.0500   -0.0000

- Fold08: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold08: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0419             nan     0.0500    0.0028
     2        0.0386             nan     0.0500    0.0027
     3        0.0361             nan     0.0500    0.0027
     4        0.0339             nan     0.0500    0.0022
     5        0.0322             nan     0.0500    0.0007
     6        0.0304             nan     0.0500    0.0017
     7        0.0289             nan     0.0500    0.0017
     8        0.0269             nan     0.0500    0.0017
     9        0.0252             nan     0.0500    0.0017
    10        0.0243             nan     0.0500    0.0002
    20        0.0156             nan     0.0500    0.0003
    40        0.0089             nan     0.0500    0.0000
    60        0.0055             nan     0.0500    0.0002
    80        0.0035             nan     0.0500   -0.0001
   100        0.0022             nan     0.0500   -0.0001
   120        0.0016             nan     0.0500   -0.0000
   140        0.0012             nan     0.0500   -0.0000
   160        0.0009             nan     0.0500   -0.0000
   180        0.0006             nan     0.0500   -0.0000
   200        0.0005             nan     0.0500    0.0000

- Fold08: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold08: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0419             nan     0.0500    0.0004
     2        0.0385             nan     0.0500    0.0031
     3        0.0367             nan     0.0500    0.0014
     4        0.0334             nan     0.0500    0.0023
     5        0.0310             nan     0.0500    0.0018
     6        0.0295             nan     0.0500    0.0014
     7        0.0274             nan     0.0500    0.0020
     8        0.0258             nan     0.0500    0.0015
     9        0.0242             nan     0.0500    0.0012
    10        0.0228             nan     0.0500    0.0006
    20        0.0121             nan     0.0500    0.0008
    40        0.0044             nan     0.0500    0.0004
    60        0.0016             nan     0.0500    0.0000
    80        0.0007             nan     0.0500   -0.0000
   100        0.0003             nan     0.0500    0.0000
   120        0.0002             nan     0.0500   -0.0000
   140        0.0001             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500    0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold08: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold08: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0410             nan     0.0500    0.0035
     2        0.0381             nan     0.0500    0.0020
     3        0.0358             nan     0.0500    0.0016
     4        0.0344             nan     0.0500    0.0014
     5        0.0317             nan     0.0500    0.0020
     6        0.0302             nan     0.0500    0.0011
     7        0.0279             nan     0.0500    0.0026
     8        0.0258             nan     0.0500    0.0011
     9        0.0245             nan     0.0500    0.0015
    10        0.0232             nan     0.0500    0.0013
    20        0.0111             nan     0.0500    0.0008
    40        0.0039             nan     0.0500    0.0000
    60        0.0020             nan     0.0500    0.0001
    80        0.0009             nan     0.0500   -0.0000
   100        0.0005             nan     0.0500   -0.0000
   120        0.0003             nan     0.0500   -0.0000
   140        0.0002             nan     0.0500   -0.0000
   160        0.0001             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold08: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold08: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0421             nan     0.0500    0.0023
     2        0.0390             nan     0.0500    0.0026
     3        0.0365             nan     0.0500    0.0027
     4        0.0345             nan     0.0500    0.0021
     5        0.0334             nan     0.0500    0.0007
     6        0.0310             nan     0.0500    0.0021
     7        0.0290             nan     0.0500    0.0006
     8        0.0274             nan     0.0500    0.0018
     9        0.0259             nan     0.0500    0.0008
    10        0.0241             nan     0.0500    0.0013
    20        0.0155             nan     0.0500    0.0002
    40        0.0074             nan     0.0500    0.0003
    60        0.0043             nan     0.0500    0.0001
    80        0.0025             nan     0.0500    0.0000
   100        0.0019             nan     0.0500    0.0000
   120        0.0014             nan     0.0500   -0.0000
   140        0.0010             nan     0.0500    0.0000
   160        0.0007             nan     0.0500    0.0000
   180        0.0005             nan     0.0500    0.0000
   200        0.0004             nan     0.0500   -0.0000

- Fold08: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold08: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0401             nan     0.0500    0.0041
     2        0.0376             nan     0.0500    0.0003
     3        0.0343             nan     0.0500    0.0019
     4        0.0312             nan     0.0500    0.0017
     5        0.0286             nan     0.0500    0.0011
     6        0.0265             nan     0.0500    0.0012
     7        0.0245             nan     0.0500    0.0014
     8        0.0230             nan     0.0500    0.0011
     9        0.0211             nan     0.0500    0.0012
    10        0.0191             nan     0.0500    0.0015
    20        0.0098             nan     0.0500    0.0005
    40        0.0027             nan     0.0500    0.0001
    60        0.0010             nan     0.0500    0.0000
    80        0.0004             nan     0.0500    0.0000
   100        0.0002             nan     0.0500    0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0000             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold08: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold08: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0422             nan     0.0500    0.0014
     2        0.0401             nan     0.0500    0.0002
     3        0.0383             nan     0.0500    0.0019
     4        0.0364             nan     0.0500    0.0021
     5        0.0339             nan     0.0500    0.0016
     6        0.0319             nan     0.0500    0.0019
     7        0.0299             nan     0.0500    0.0008
     8        0.0280             nan     0.0500    0.0014
     9        0.0270             nan     0.0500    0.0005
    10        0.0258             nan     0.0500    0.0005
    20        0.0125             nan     0.0500    0.0008
    40        0.0038             nan     0.0500    0.0001
    60        0.0019             nan     0.0500   -0.0000
    80        0.0012             nan     0.0500   -0.0000
   100        0.0008             nan     0.0500   -0.0000
   120        0.0005             nan     0.0500   -0.0000
   140        0.0003             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0002             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold08: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold08: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0411             nan     0.0500    0.0025
     2        0.0392             nan     0.0500    0.0011
     3        0.0361             nan     0.0500    0.0025
     4        0.0331             nan     0.0500    0.0021
     5        0.0312             nan     0.0500    0.0021
     6        0.0287             nan     0.0500    0.0018
     7        0.0267             nan     0.0500    0.0018
     8        0.0257             nan     0.0500    0.0005
     9        0.0249             nan     0.0500   -0.0005
    10        0.0237             nan     0.0500    0.0014
    20        0.0154             nan     0.0500    0.0007
    40        0.0087             nan     0.0500    0.0002
    60        0.0058             nan     0.0500   -0.0002
    80        0.0039             nan     0.0500   -0.0000
   100        0.0026             nan     0.0500    0.0000
   120        0.0018             nan     0.0500   -0.0001
   140        0.0014             nan     0.0500   -0.0000
   160        0.0010             nan     0.0500   -0.0000
   180        0.0009             nan     0.0500   -0.0000
   200        0.0006             nan     0.0500   -0.0000

- Fold08: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold08: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0405             nan     0.1000    0.0036
     2        0.0373             nan     0.1000    0.0014
     3        0.0331             nan     0.1000    0.0030
     4        0.0294             nan     0.1000    0.0039
     5        0.0273             nan     0.1000    0.0008
     6        0.0253             nan     0.1000    0.0019
     7        0.0230             nan     0.1000    0.0027
     8        0.0210             nan     0.1000    0.0016
     9        0.0193             nan     0.1000    0.0018
    10        0.0181             nan     0.1000    0.0004
    20        0.0068             nan     0.1000    0.0001
    40        0.0017             nan     0.1000    0.0000
    60        0.0005             nan     0.1000   -0.0000
    80        0.0002             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000    0.0000

- Fold08: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold08: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0403             nan     0.1000    0.0007
     2        0.0345             nan     0.1000    0.0054
     3        0.0299             nan     0.1000    0.0021
     4        0.0261             nan     0.1000    0.0039
     5        0.0233             nan     0.1000    0.0032
     6        0.0196             nan     0.1000    0.0027
     7        0.0180             nan     0.1000    0.0015
     8        0.0161             nan     0.1000    0.0017
     9        0.0140             nan     0.1000    0.0006
    10        0.0124             nan     0.1000    0.0011
    20        0.0060             nan     0.1000    0.0005
    40        0.0019             nan     0.1000    0.0001
    60        0.0007             nan     0.1000   -0.0001
    80        0.0003             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000    0.0000

- Fold08: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold08: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0380             nan     0.1000    0.0062
     2        0.0337             nan     0.1000    0.0029
     3        0.0307             nan     0.1000    0.0028
     4        0.0286             nan     0.1000    0.0003
     5        0.0258             nan     0.1000    0.0015
     6        0.0225             nan     0.1000    0.0011
     7        0.0203             nan     0.1000    0.0011
     8        0.0188             nan     0.1000    0.0013
     9        0.0172             nan     0.1000    0.0006
    10        0.0152             nan     0.1000    0.0018
    20        0.0082             nan     0.1000   -0.0000
    40        0.0041             nan     0.1000    0.0001
    60        0.0019             nan     0.1000    0.0000
    80        0.0010             nan     0.1000   -0.0001
   100        0.0005             nan     0.1000   -0.0000
   120        0.0003             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000    0.0000
   160        0.0002             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold08: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold08: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0400             nan     0.1000    0.0015
     2        0.0351             nan     0.1000    0.0020
     3        0.0303             nan     0.1000    0.0050
     4        0.0277             nan     0.1000    0.0017
     5        0.0244             nan     0.1000    0.0013
     6        0.0211             nan     0.1000    0.0031
     7        0.0192             nan     0.1000    0.0022
     8        0.0167             nan     0.1000    0.0021
     9        0.0143             nan     0.1000    0.0018
    10        0.0139             nan     0.1000   -0.0018
    20        0.0047             nan     0.1000    0.0001
    40        0.0006             nan     0.1000   -0.0001
    60        0.0001             nan     0.1000    0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold08: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold08: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0387             nan     0.1000    0.0068
     2        0.0330             nan     0.1000    0.0045
     3        0.0284             nan     0.1000    0.0027
     4        0.0244             nan     0.1000    0.0038
     5        0.0207             nan     0.1000    0.0034
     6        0.0183             nan     0.1000    0.0020
     7        0.0176             nan     0.1000    0.0008
     8        0.0153             nan     0.1000    0.0011
     9        0.0142             nan     0.1000    0.0010
    10        0.0126             nan     0.1000    0.0007
    20        0.0043             nan     0.1000    0.0003
    40        0.0010             nan     0.1000    0.0000
    60        0.0004             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold08: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold08: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0386             nan     0.1000    0.0054
     2        0.0348             nan     0.1000    0.0029
     3        0.0302             nan     0.1000    0.0041
     4        0.0266             nan     0.1000    0.0035
     5        0.0231             nan     0.1000    0.0023
     6        0.0203             nan     0.1000    0.0023
     7        0.0183             nan     0.1000    0.0020
     8        0.0167             nan     0.1000    0.0012
     9        0.0148             nan     0.1000    0.0015
    10        0.0132             nan     0.1000    0.0010
    20        0.0073             nan     0.1000   -0.0001
    40        0.0025             nan     0.1000    0.0001
    60        0.0013             nan     0.1000   -0.0001
    80        0.0007             nan     0.1000   -0.0000
   100        0.0004             nan     0.1000    0.0000
   120        0.0003             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000    0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold08: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold08: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0368             nan     0.1000    0.0077
     2        0.0309             nan     0.1000    0.0048
     3        0.0264             nan     0.1000    0.0041
     4        0.0220             nan     0.1000    0.0031
     5        0.0185             nan     0.1000    0.0023
     6        0.0163             nan     0.1000    0.0017
     7        0.0137             nan     0.1000    0.0025
     8        0.0119             nan     0.1000    0.0010
     9        0.0101             nan     0.1000    0.0003
    10        0.0085             nan     0.1000    0.0003
    20        0.0028             nan     0.1000    0.0002
    40        0.0004             nan     0.1000   -0.0000
    60        0.0001             nan     0.1000    0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold08: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold08: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0384             nan     0.1000    0.0063
     2        0.0313             nan     0.1000    0.0062
     3        0.0267             nan     0.1000    0.0036
     4        0.0243             nan     0.1000    0.0016
     5        0.0214             nan     0.1000    0.0027
     6        0.0200             nan     0.1000    0.0007
     7        0.0174             nan     0.1000    0.0020
     8        0.0168             nan     0.1000   -0.0007
     9        0.0154             nan     0.1000    0.0009
    10        0.0143             nan     0.1000    0.0011
    20        0.0053             nan     0.1000    0.0007
    40        0.0013             nan     0.1000    0.0001
    60        0.0004             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000    0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold08: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold08: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0379             nan     0.1000    0.0057
     2        0.0338             nan     0.1000    0.0035
     3        0.0290             nan     0.1000    0.0035
     4        0.0252             nan     0.1000    0.0032
     5        0.0232             nan     0.1000    0.0016
     6        0.0201             nan     0.1000    0.0020
     7        0.0187             nan     0.1000    0.0009
     8        0.0171             nan     0.1000    0.0007
     9        0.0153             nan     0.1000    0.0014
    10        0.0149             nan     0.1000   -0.0012
    20        0.0083             nan     0.1000    0.0002
    40        0.0036             nan     0.1000   -0.0001
    60        0.0018             nan     0.1000    0.0001
    80        0.0010             nan     0.1000   -0.0000
   100        0.0005             nan     0.1000   -0.0000
   120        0.0003             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold08: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold09: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0403             nan     0.0100    0.0005
     2        0.0398             nan     0.0100    0.0004
     3        0.0393             nan     0.0100    0.0005
     4        0.0388             nan     0.0100    0.0004
     5        0.0384             nan     0.0100    0.0003
     6        0.0381             nan     0.0100   -0.0000
     7        0.0378             nan     0.0100    0.0001
     8        0.0373             nan     0.0100    0.0004
     9        0.0369             nan     0.0100    0.0005
    10        0.0363             nan     0.0100    0.0005
    20        0.0322             nan     0.0100    0.0003
    40        0.0258             nan     0.0100    0.0002
    60        0.0207             nan     0.0100   -0.0001
    80        0.0166             nan     0.0100    0.0002
   100        0.0139             nan     0.0100   -0.0001
   120        0.0114             nan     0.0100    0.0001
   140        0.0097             nan     0.0100    0.0001
   160        0.0082             nan     0.0100    0.0000
   180        0.0069             nan     0.0100    0.0000
   200        0.0058             nan     0.0100    0.0000

- Fold09: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold09: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0402             nan     0.0100    0.0006
     2        0.0396             nan     0.0100    0.0005
     3        0.0390             nan     0.0100    0.0005
     4        0.0385             nan     0.0100    0.0004
     5        0.0380             nan     0.0100    0.0005
     6        0.0376             nan     0.0100    0.0004
     7        0.0372             nan     0.0100    0.0004
     8        0.0367             nan     0.0100    0.0004
     9        0.0364             nan     0.0100    0.0002
    10        0.0360             nan     0.0100    0.0004
    20        0.0320             nan     0.0100    0.0003
    40        0.0255             nan     0.0100    0.0002
    60        0.0207             nan     0.0100    0.0002
    80        0.0172             nan     0.0100    0.0001
   100        0.0139             nan     0.0100    0.0000
   120        0.0114             nan     0.0100    0.0000
   140        0.0095             nan     0.0100    0.0001
   160        0.0081             nan     0.0100    0.0001
   180        0.0070             nan     0.0100    0.0000
   200        0.0061             nan     0.0100    0.0000

- Fold09: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold09: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0405             nan     0.0100    0.0002
     2        0.0401             nan     0.0100    0.0003
     3        0.0396             nan     0.0100    0.0004
     4        0.0391             nan     0.0100    0.0005
     5        0.0387             nan     0.0100    0.0005
     6        0.0382             nan     0.0100    0.0004
     7        0.0378             nan     0.0100    0.0005
     8        0.0375             nan     0.0100    0.0002
     9        0.0371             nan     0.0100    0.0004
    10        0.0367             nan     0.0100    0.0003
    20        0.0323             nan     0.0100    0.0004
    40        0.0264             nan     0.0100    0.0002
    60        0.0213             nan     0.0100    0.0003
    80        0.0180             nan     0.0100    0.0000
   100        0.0148             nan     0.0100    0.0001
   120        0.0128             nan     0.0100    0.0000
   140        0.0112             nan     0.0100    0.0000
   160        0.0100             nan     0.0100    0.0000
   180        0.0088             nan     0.0100    0.0000
   200        0.0078             nan     0.0100   -0.0000

- Fold09: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold09: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0402             nan     0.0100    0.0001
     2        0.0395             nan     0.0100    0.0006
     3        0.0392             nan     0.0100    0.0004
     4        0.0385             nan     0.0100    0.0008
     5        0.0381             nan     0.0100    0.0005
     6        0.0376             nan     0.0100    0.0001
     7        0.0371             nan     0.0100    0.0000
     8        0.0368             nan     0.0100    0.0003
     9        0.0363             nan     0.0100    0.0002
    10        0.0357             nan     0.0100    0.0003
    20        0.0311             nan     0.0100    0.0005
    40        0.0238             nan     0.0100    0.0001
    60        0.0185             nan     0.0100    0.0001
    80        0.0142             nan     0.0100    0.0003
   100        0.0107             nan     0.0100    0.0001
   120        0.0088             nan     0.0100   -0.0000
   140        0.0070             nan     0.0100   -0.0000
   160        0.0056             nan     0.0100    0.0000
   180        0.0045             nan     0.0100    0.0000
   200        0.0037             nan     0.0100    0.0000

- Fold09: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold09: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0404             nan     0.0100    0.0005
     2        0.0402             nan     0.0100   -0.0001
     3        0.0396             nan     0.0100    0.0005
     4        0.0391             nan     0.0100    0.0005
     5        0.0390             nan     0.0100   -0.0002
     6        0.0384             nan     0.0100    0.0004
     7        0.0379             nan     0.0100    0.0006
     8        0.0373             nan     0.0100    0.0005
     9        0.0367             nan     0.0100    0.0002
    10        0.0362             nan     0.0100    0.0005
    20        0.0311             nan     0.0100    0.0003
    40        0.0238             nan     0.0100    0.0003
    60        0.0185             nan     0.0100    0.0002
    80        0.0145             nan     0.0100    0.0002
   100        0.0116             nan     0.0100    0.0001
   120        0.0096             nan     0.0100    0.0001
   140        0.0076             nan     0.0100    0.0001
   160        0.0061             nan     0.0100    0.0000
   180        0.0051             nan     0.0100    0.0001
   200        0.0041             nan     0.0100    0.0000

- Fold09: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold09: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0404             nan     0.0100    0.0004
     2        0.0400             nan     0.0100    0.0003
     3        0.0394             nan     0.0100    0.0004
     4        0.0390             nan     0.0100    0.0005
     5        0.0388             nan     0.0100    0.0002
     6        0.0384             nan     0.0100    0.0003
     7        0.0378             nan     0.0100    0.0003
     8        0.0374             nan     0.0100    0.0004
     9        0.0371             nan     0.0100    0.0003
    10        0.0367             nan     0.0100    0.0003
    20        0.0323             nan     0.0100    0.0000
    40        0.0256             nan     0.0100    0.0003
    60        0.0213             nan     0.0100    0.0002
    80        0.0174             nan     0.0100    0.0002
   100        0.0144             nan     0.0100    0.0001
   120        0.0121             nan     0.0100    0.0001
   140        0.0107             nan     0.0100    0.0001
   160        0.0092             nan     0.0100   -0.0000
   180        0.0081             nan     0.0100    0.0000
   200        0.0071             nan     0.0100    0.0000

- Fold09: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold09: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0403             nan     0.0100    0.0002
     2        0.0396             nan     0.0100    0.0005
     3        0.0390             nan     0.0100    0.0006
     4        0.0382             nan     0.0100    0.0006
     5        0.0376             nan     0.0100    0.0006
     6        0.0370             nan     0.0100    0.0005
     7        0.0363             nan     0.0100    0.0007
     8        0.0356             nan     0.0100    0.0006
     9        0.0352             nan     0.0100    0.0002
    10        0.0348             nan     0.0100    0.0005
    20        0.0303             nan     0.0100    0.0003
    40        0.0231             nan     0.0100    0.0002
    60        0.0177             nan     0.0100    0.0001
    80        0.0134             nan     0.0100    0.0000
   100        0.0102             nan     0.0100    0.0001
   120        0.0080             nan     0.0100    0.0000
   140        0.0061             nan     0.0100    0.0000
   160        0.0048             nan     0.0100    0.0000
   180        0.0038             nan     0.0100    0.0000
   200        0.0031             nan     0.0100   -0.0000

- Fold09: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold09: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0404             nan     0.0100    0.0005
     2        0.0398             nan     0.0100    0.0005
     3        0.0392             nan     0.0100    0.0006
     4        0.0387             nan     0.0100    0.0006
     5        0.0380             nan     0.0100    0.0004
     6        0.0374             nan     0.0100    0.0003
     7        0.0369             nan     0.0100    0.0005
     8        0.0365             nan     0.0100    0.0004
     9        0.0361             nan     0.0100    0.0004
    10        0.0356             nan     0.0100    0.0004
    20        0.0312             nan     0.0100    0.0004
    40        0.0236             nan     0.0100    0.0003
    60        0.0186             nan     0.0100    0.0001
    80        0.0146             nan     0.0100    0.0002
   100        0.0116             nan     0.0100    0.0000
   120        0.0093             nan     0.0100    0.0000
   140        0.0073             nan     0.0100    0.0001
   160        0.0060             nan     0.0100   -0.0000
   180        0.0048             nan     0.0100    0.0000
   200        0.0039             nan     0.0100    0.0000

- Fold09: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold09: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0404             nan     0.0100    0.0005
     2        0.0400             nan     0.0100    0.0001
     3        0.0395             nan     0.0100    0.0004
     4        0.0390             nan     0.0100    0.0005
     5        0.0385             nan     0.0100    0.0001
     6        0.0380             nan     0.0100    0.0005
     7        0.0376             nan     0.0100    0.0004
     8        0.0371             nan     0.0100    0.0005
     9        0.0366             nan     0.0100    0.0005
    10        0.0362             nan     0.0100    0.0004
    20        0.0319             nan     0.0100    0.0002
    40        0.0255             nan     0.0100    0.0003
    60        0.0209             nan     0.0100    0.0001
    80        0.0175             nan     0.0100    0.0000
   100        0.0147             nan     0.0100    0.0001
   120        0.0126             nan     0.0100    0.0001
   140        0.0108             nan     0.0100    0.0001
   160        0.0093             nan     0.0100    0.0001
   180        0.0082             nan     0.0100   -0.0000
   200        0.0073             nan     0.0100   -0.0000

- Fold09: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold09: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0383             nan     0.0500    0.0025
     2        0.0359             nan     0.0500    0.0023
     3        0.0338             nan     0.0500    0.0018
     4        0.0319             nan     0.0500    0.0009
     5        0.0297             nan     0.0500    0.0014
     6        0.0283             nan     0.0500    0.0011
     7        0.0267             nan     0.0500    0.0019
     8        0.0253             nan     0.0500    0.0014
     9        0.0239             nan     0.0500    0.0013
    10        0.0220             nan     0.0500    0.0017
    20        0.0141             nan     0.0500    0.0003
    40        0.0059             nan     0.0500    0.0002
    60        0.0028             nan     0.0500    0.0000
    80        0.0013             nan     0.0500    0.0000
   100        0.0007             nan     0.0500   -0.0000
   120        0.0005             nan     0.0500   -0.0000
   140        0.0003             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold09: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold09: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0380             nan     0.0500    0.0023
     2        0.0365             nan     0.0500    0.0014
     3        0.0347             nan     0.0500    0.0019
     4        0.0332             nan     0.0500    0.0014
     5        0.0311             nan     0.0500    0.0021
     6        0.0301             nan     0.0500    0.0003
     7        0.0284             nan     0.0500    0.0017
     8        0.0266             nan     0.0500    0.0017
     9        0.0256             nan     0.0500    0.0002
    10        0.0241             nan     0.0500    0.0014
    20        0.0137             nan     0.0500    0.0005
    40        0.0055             nan     0.0500    0.0002
    60        0.0025             nan     0.0500    0.0000
    80        0.0016             nan     0.0500    0.0000
   100        0.0010             nan     0.0500    0.0000
   120        0.0007             nan     0.0500   -0.0000
   140        0.0004             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500    0.0000
   180        0.0002             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold09: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold09: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0380             nan     0.0500    0.0022
     2        0.0357             nan     0.0500    0.0021
     3        0.0341             nan     0.0500    0.0006
     4        0.0318             nan     0.0500    0.0024
     5        0.0303             nan     0.0500    0.0013
     6        0.0290             nan     0.0500    0.0010
     7        0.0277             nan     0.0500    0.0009
     8        0.0266             nan     0.0500    0.0006
     9        0.0250             nan     0.0500    0.0016
    10        0.0236             nan     0.0500    0.0013
    20        0.0149             nan     0.0500    0.0005
    40        0.0067             nan     0.0500    0.0002
    60        0.0040             nan     0.0500    0.0000
    80        0.0026             nan     0.0500    0.0000
   100        0.0018             nan     0.0500   -0.0000
   120        0.0011             nan     0.0500   -0.0000
   140        0.0008             nan     0.0500    0.0000
   160        0.0006             nan     0.0500   -0.0000
   180        0.0005             nan     0.0500   -0.0000
   200        0.0004             nan     0.0500   -0.0000

- Fold09: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold09: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0383             nan     0.0500    0.0020
     2        0.0367             nan     0.0500    0.0013
     3        0.0344             nan     0.0500    0.0018
     4        0.0317             nan     0.0500    0.0017
     5        0.0293             nan     0.0500    0.0006
     6        0.0275             nan     0.0500    0.0003
     7        0.0261             nan     0.0500    0.0006
     8        0.0249             nan     0.0500    0.0001
     9        0.0230             nan     0.0500    0.0017
    10        0.0212             nan     0.0500    0.0011
    20        0.0112             nan     0.0500    0.0004
    40        0.0040             nan     0.0500    0.0000
    60        0.0017             nan     0.0500   -0.0000
    80        0.0008             nan     0.0500   -0.0000
   100        0.0004             nan     0.0500   -0.0000
   120        0.0002             nan     0.0500    0.0000
   140        0.0001             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500    0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold09: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold09: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0395             nan     0.0500   -0.0003
     2        0.0371             nan     0.0500    0.0025
     3        0.0340             nan     0.0500    0.0021
     4        0.0311             nan     0.0500    0.0014
     5        0.0287             nan     0.0500    0.0018
     6        0.0267             nan     0.0500    0.0018
     7        0.0254             nan     0.0500    0.0010
     8        0.0244             nan     0.0500    0.0002
     9        0.0232             nan     0.0500   -0.0003
    10        0.0216             nan     0.0500    0.0010
    20        0.0117             nan     0.0500    0.0005
    40        0.0043             nan     0.0500    0.0001
    60        0.0018             nan     0.0500    0.0001
    80        0.0010             nan     0.0500    0.0000
   100        0.0005             nan     0.0500    0.0000
   120        0.0003             nan     0.0500    0.0000
   140        0.0002             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold09: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold09: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0379             nan     0.0500    0.0025
     2        0.0357             nan     0.0500    0.0019
     3        0.0335             nan     0.0500    0.0017
     4        0.0320             nan     0.0500    0.0015
     5        0.0301             nan     0.0500    0.0021
     6        0.0285             nan     0.0500    0.0017
     7        0.0273             nan     0.0500    0.0002
     8        0.0256             nan     0.0500    0.0002
     9        0.0236             nan     0.0500    0.0011
    10        0.0228             nan     0.0500   -0.0001
    20        0.0141             nan     0.0500    0.0007
    40        0.0075             nan     0.0500    0.0002
    60        0.0045             nan     0.0500    0.0001
    80        0.0030             nan     0.0500   -0.0000
   100        0.0021             nan     0.0500    0.0000
   120        0.0013             nan     0.0500   -0.0000
   140        0.0009             nan     0.0500    0.0000
   160        0.0007             nan     0.0500    0.0000
   180        0.0005             nan     0.0500    0.0000
   200        0.0004             nan     0.0500    0.0000

- Fold09: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold09: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0379             nan     0.0500    0.0026
     2        0.0352             nan     0.0500    0.0002
     3        0.0319             nan     0.0500    0.0030
     4        0.0295             nan     0.0500    0.0015
     5        0.0288             nan     0.0500   -0.0001
     6        0.0261             nan     0.0500    0.0022
     7        0.0239             nan     0.0500    0.0026
     8        0.0215             nan     0.0500    0.0021
     9        0.0200             nan     0.0500    0.0005
    10        0.0193             nan     0.0500   -0.0001
    20        0.0110             nan     0.0500    0.0003
    40        0.0030             nan     0.0500    0.0003
    60        0.0010             nan     0.0500    0.0000
    80        0.0004             nan     0.0500    0.0000
   100        0.0002             nan     0.0500    0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0000             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500    0.0000

- Fold09: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold09: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0377             nan     0.0500    0.0024
     2        0.0358             nan     0.0500    0.0004
     3        0.0334             nan     0.0500    0.0019
     4        0.0312             nan     0.0500    0.0004
     5        0.0299             nan     0.0500    0.0003
     6        0.0287             nan     0.0500    0.0002
     7        0.0263             nan     0.0500    0.0018
     8        0.0242             nan     0.0500    0.0018
     9        0.0237             nan     0.0500   -0.0003
    10        0.0221             nan     0.0500    0.0013
    20        0.0121             nan     0.0500    0.0007
    40        0.0044             nan     0.0500   -0.0000
    60        0.0019             nan     0.0500   -0.0001
    80        0.0009             nan     0.0500    0.0000
   100        0.0005             nan     0.0500    0.0000
   120        0.0003             nan     0.0500   -0.0000
   140        0.0002             nan     0.0500    0.0000
   160        0.0001             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold09: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold09: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0380             nan     0.0500    0.0028
     2        0.0358             nan     0.0500    0.0022
     3        0.0344             nan     0.0500    0.0010
     4        0.0333             nan     0.0500    0.0011
     5        0.0309             nan     0.0500    0.0018
     6        0.0294             nan     0.0500    0.0006
     7        0.0278             nan     0.0500    0.0010
     8        0.0262             nan     0.0500    0.0017
     9        0.0248             nan     0.0500    0.0013
    10        0.0234             nan     0.0500    0.0008
    20        0.0128             nan     0.0500    0.0000
    40        0.0054             nan     0.0500    0.0001
    60        0.0032             nan     0.0500   -0.0000
    80        0.0020             nan     0.0500    0.0000
   100        0.0013             nan     0.0500    0.0000
   120        0.0009             nan     0.0500   -0.0000
   140        0.0006             nan     0.0500    0.0000
   160        0.0005             nan     0.0500   -0.0000
   180        0.0004             nan     0.0500   -0.0000
   200        0.0003             nan     0.0500   -0.0000

- Fold09: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold09: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0375             nan     0.1000    0.0027
     2        0.0321             nan     0.1000    0.0041
     3        0.0279             nan     0.1000    0.0012
     4        0.0244             nan     0.1000    0.0023
     5        0.0217             nan     0.1000    0.0022
     6        0.0198             nan     0.1000    0.0010
     7        0.0182             nan     0.1000    0.0016
     8        0.0162             nan     0.1000    0.0014
     9        0.0151             nan     0.1000    0.0010
    10        0.0139             nan     0.1000    0.0009
    20        0.0057             nan     0.1000    0.0002
    40        0.0018             nan     0.1000    0.0000
    60        0.0008             nan     0.1000   -0.0000
    80        0.0004             nan     0.1000   -0.0000
   100        0.0002             nan     0.1000   -0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold09: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold09: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0367             nan     0.1000    0.0036
     2        0.0317             nan     0.1000    0.0045
     3        0.0275             nan     0.1000    0.0036
     4        0.0237             nan     0.1000    0.0020
     5        0.0213             nan     0.1000    0.0024
     6        0.0190             nan     0.1000    0.0015
     7        0.0166             nan     0.1000    0.0019
     8        0.0159             nan     0.1000   -0.0011
     9        0.0146             nan     0.1000    0.0006
    10        0.0135             nan     0.1000    0.0004
    20        0.0064             nan     0.1000    0.0007
    40        0.0020             nan     0.1000    0.0001
    60        0.0007             nan     0.1000    0.0000
    80        0.0003             nan     0.1000    0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000    0.0000

- Fold09: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold09: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0364             nan     0.1000    0.0037
     2        0.0333             nan     0.1000    0.0011
     3        0.0311             nan     0.1000    0.0011
     4        0.0282             nan     0.1000    0.0011
     5        0.0257             nan     0.1000    0.0007
     6        0.0225             nan     0.1000    0.0015
     7        0.0198             nan     0.1000    0.0022
     8        0.0180             nan     0.1000    0.0019
     9        0.0169             nan     0.1000    0.0012
    10        0.0148             nan     0.1000    0.0012
    20        0.0074             nan     0.1000    0.0005
    40        0.0030             nan     0.1000   -0.0000
    60        0.0014             nan     0.1000   -0.0001
    80        0.0007             nan     0.1000   -0.0000
   100        0.0004             nan     0.1000   -0.0000
   120        0.0002             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold09: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold09: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0387             nan     0.1000   -0.0016
     2        0.0346             nan     0.1000   -0.0003
     3        0.0294             nan     0.1000    0.0051
     4        0.0260             nan     0.1000    0.0038
     5        0.0233             nan     0.1000    0.0027
     6        0.0198             nan     0.1000    0.0013
     7        0.0175             nan     0.1000    0.0022
     8        0.0162             nan     0.1000    0.0016
     9        0.0131             nan     0.1000    0.0016
    10        0.0116             nan     0.1000   -0.0001
    20        0.0042             nan     0.1000    0.0003
    40        0.0010             nan     0.1000    0.0000
    60        0.0004             nan     0.1000    0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold09: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold09: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0350             nan     0.1000    0.0054
     2        0.0302             nan     0.1000    0.0055
     3        0.0266             nan     0.1000    0.0034
     4        0.0227             nan     0.1000    0.0030
     5        0.0194             nan     0.1000    0.0024
     6        0.0171             nan     0.1000    0.0023
     7        0.0151             nan     0.1000   -0.0002
     8        0.0136             nan     0.1000    0.0014
     9        0.0115             nan     0.1000    0.0018
    10        0.0102             nan     0.1000    0.0009
    20        0.0037             nan     0.1000    0.0003
    40        0.0009             nan     0.1000   -0.0001
    60        0.0003             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold09: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold09: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0359             nan     0.1000    0.0055
     2        0.0319             nan     0.1000    0.0029
     3        0.0273             nan     0.1000    0.0026
     4        0.0257             nan     0.1000    0.0005
     5        0.0251             nan     0.1000   -0.0001
     6        0.0239             nan     0.1000    0.0004
     7        0.0217             nan     0.1000    0.0017
     8        0.0195             nan     0.1000   -0.0003
     9        0.0181             nan     0.1000    0.0017
    10        0.0161             nan     0.1000    0.0004
    20        0.0080             nan     0.1000    0.0004
    40        0.0034             nan     0.1000   -0.0000
    60        0.0019             nan     0.1000    0.0001
    80        0.0012             nan     0.1000   -0.0000
   100        0.0007             nan     0.1000    0.0000
   120        0.0005             nan     0.1000   -0.0000
   140        0.0003             nan     0.1000   -0.0000
   160        0.0002             nan     0.1000    0.0000
   180        0.0001             nan     0.1000    0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold09: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold09: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0338             nan     0.1000    0.0049
     2        0.0298             nan     0.1000    0.0007
     3        0.0256             nan     0.1000    0.0035
     4        0.0229             nan     0.1000    0.0008
     5        0.0194             nan     0.1000    0.0038
     6        0.0170             nan     0.1000    0.0025
     7        0.0142             nan     0.1000    0.0022
     8        0.0120             nan     0.1000    0.0014
     9        0.0110             nan     0.1000   -0.0005
    10        0.0097             nan     0.1000    0.0009
    20        0.0035             nan     0.1000    0.0003
    40        0.0005             nan     0.1000   -0.0000
    60        0.0001             nan     0.1000    0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold09: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold09: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0350             nan     0.1000    0.0059
     2        0.0307             nan     0.1000    0.0034
     3        0.0274             nan     0.1000    0.0024
     4        0.0252             nan     0.1000    0.0010
     5        0.0217             nan     0.1000    0.0024
     6        0.0197             nan     0.1000    0.0025
     7        0.0186             nan     0.1000    0.0009
     8        0.0167             nan     0.1000    0.0003
     9        0.0152             nan     0.1000    0.0018
    10        0.0136             nan     0.1000    0.0018
    20        0.0038             nan     0.1000    0.0001
    40        0.0016             nan     0.1000   -0.0001
    60        0.0008             nan     0.1000   -0.0000
    80        0.0004             nan     0.1000   -0.0000
   100        0.0002             nan     0.1000   -0.0000
   120        0.0001             nan     0.1000    0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000    0.0000

- Fold09: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold09: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0340             nan     0.1000    0.0051
     2        0.0305             nan     0.1000    0.0032
     3        0.0271             nan     0.1000    0.0034
     4        0.0243             nan     0.1000    0.0028
     5        0.0217             nan     0.1000    0.0020
     6        0.0194             nan     0.1000    0.0022
     7        0.0176             nan     0.1000    0.0015
     8        0.0157             nan     0.1000    0.0012
     9        0.0142             nan     0.1000    0.0017
    10        0.0136             nan     0.1000    0.0001
    20        0.0067             nan     0.1000   -0.0004
    40        0.0028             nan     0.1000   -0.0002
    60        0.0012             nan     0.1000   -0.0000
    80        0.0005             nan     0.1000    0.0000
   100        0.0003             nan     0.1000   -0.0000
   120        0.0002             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000    0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold09: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold10: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0436             nan     0.0100    0.0003
     2        0.0432             nan     0.0100    0.0001
     3        0.0426             nan     0.0100    0.0005
     4        0.0421             nan     0.0100    0.0000
     5        0.0418             nan     0.0100    0.0001
     6        0.0413             nan     0.0100    0.0004
     7        0.0408             nan     0.0100    0.0006
     8        0.0402             nan     0.0100    0.0005
     9        0.0397             nan     0.0100    0.0004
    10        0.0391             nan     0.0100    0.0005
    20        0.0349             nan     0.0100    0.0004
    40        0.0276             nan     0.0100    0.0000
    60        0.0224             nan     0.0100    0.0002
    80        0.0177             nan     0.0100    0.0002
   100        0.0145             nan     0.0100    0.0001
   120        0.0123             nan     0.0100    0.0000
   140        0.0105             nan     0.0100   -0.0000
   160        0.0087             nan     0.0100    0.0000
   180        0.0072             nan     0.0100    0.0000
   200        0.0061             nan     0.0100    0.0001

- Fold10: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold10: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0434             nan     0.0100    0.0006
     2        0.0429             nan     0.0100    0.0002
     3        0.0424             nan     0.0100    0.0005
     4        0.0420             nan     0.0100    0.0002
     5        0.0414             nan     0.0100    0.0005
     6        0.0413             nan     0.0100   -0.0002
     7        0.0408             nan     0.0100    0.0004
     8        0.0404             nan     0.0100    0.0004
     9        0.0399             nan     0.0100    0.0005
    10        0.0396             nan     0.0100    0.0002
    20        0.0346             nan     0.0100    0.0004
    40        0.0276             nan     0.0100    0.0004
    60        0.0223             nan     0.0100    0.0002
    80        0.0187             nan     0.0100    0.0001
   100        0.0152             nan     0.0100    0.0001
   120        0.0128             nan     0.0100    0.0001
   140        0.0106             nan     0.0100    0.0000
   160        0.0089             nan     0.0100   -0.0001
   180        0.0075             nan     0.0100    0.0000
   200        0.0063             nan     0.0100    0.0000

- Fold10: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold10: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0435             nan     0.0100    0.0001
     2        0.0430             nan     0.0100    0.0005
     3        0.0427             nan     0.0100    0.0002
     4        0.0422             nan     0.0100    0.0004
     5        0.0416             nan     0.0100    0.0003
     6        0.0410             nan     0.0100    0.0005
     7        0.0406             nan     0.0100    0.0003
     8        0.0402             nan     0.0100    0.0005
     9        0.0396             nan     0.0100    0.0004
    10        0.0391             nan     0.0100    0.0005
    20        0.0348             nan     0.0100    0.0005
    40        0.0284             nan     0.0100    0.0001
    60        0.0233             nan     0.0100   -0.0001
    80        0.0191             nan     0.0100    0.0001
   100        0.0161             nan     0.0100    0.0001
   120        0.0138             nan     0.0100    0.0001
   140        0.0120             nan     0.0100    0.0000
   160        0.0104             nan     0.0100    0.0000
   180        0.0091             nan     0.0100    0.0000
   200        0.0081             nan     0.0100    0.0000

- Fold10: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold10: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0438             nan     0.0100   -0.0001
     2        0.0431             nan     0.0100    0.0005
     3        0.0424             nan     0.0100    0.0007
     4        0.0421             nan     0.0100    0.0003
     5        0.0414             nan     0.0100    0.0002
     6        0.0406             nan     0.0100    0.0006
     7        0.0402             nan     0.0100    0.0003
     8        0.0394             nan     0.0100    0.0006
     9        0.0389             nan     0.0100    0.0005
    10        0.0384             nan     0.0100    0.0002
    20        0.0339             nan     0.0100    0.0001
    40        0.0252             nan     0.0100    0.0001
    60        0.0198             nan     0.0100    0.0000
    80        0.0152             nan     0.0100    0.0000
   100        0.0118             nan     0.0100    0.0001
   120        0.0092             nan     0.0100    0.0001
   140        0.0075             nan     0.0100    0.0000
   160        0.0059             nan     0.0100    0.0001
   180        0.0047             nan     0.0100    0.0000
   200        0.0038             nan     0.0100    0.0000

- Fold10: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold10: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0434             nan     0.0100    0.0006
     2        0.0427             nan     0.0100    0.0006
     3        0.0423             nan     0.0100    0.0004
     4        0.0417             nan     0.0100    0.0004
     5        0.0416             nan     0.0100   -0.0003
     6        0.0410             nan     0.0100    0.0004
     7        0.0405             nan     0.0100    0.0005
     8        0.0400             nan     0.0100    0.0005
     9        0.0393             nan     0.0100    0.0007
    10        0.0387             nan     0.0100    0.0005
    20        0.0342             nan     0.0100    0.0004
    40        0.0262             nan     0.0100   -0.0000
    60        0.0200             nan     0.0100    0.0002
    80        0.0154             nan     0.0100    0.0002
   100        0.0124             nan     0.0100   -0.0000
   120        0.0097             nan     0.0100    0.0001
   140        0.0079             nan     0.0100    0.0001
   160        0.0063             nan     0.0100    0.0001
   180        0.0051             nan     0.0100   -0.0000
   200        0.0040             nan     0.0100    0.0000

- Fold10: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold10: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0435             nan     0.0100    0.0004
     2        0.0432             nan     0.0100    0.0001
     3        0.0427             nan     0.0100    0.0006
     4        0.0421             nan     0.0100    0.0006
     5        0.0416             nan     0.0100    0.0005
     6        0.0410             nan     0.0100    0.0005
     7        0.0406             nan     0.0100    0.0003
     8        0.0401             nan     0.0100    0.0005
     9        0.0396             nan     0.0100    0.0004
    10        0.0392             nan     0.0100    0.0004
    20        0.0349             nan     0.0100    0.0004
    40        0.0282             nan     0.0100    0.0003
    60        0.0229             nan     0.0100   -0.0001
    80        0.0189             nan     0.0100    0.0002
   100        0.0162             nan     0.0100    0.0001
   120        0.0138             nan     0.0100    0.0001
   140        0.0120             nan     0.0100    0.0001
   160        0.0105             nan     0.0100    0.0001
   180        0.0094             nan     0.0100   -0.0000
   200        0.0085             nan     0.0100    0.0000

- Fold10: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold10: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0432             nan     0.0100    0.0006
     2        0.0428             nan     0.0100    0.0003
     3        0.0421             nan     0.0100    0.0008
     4        0.0415             nan     0.0100    0.0004
     5        0.0409             nan     0.0100    0.0005
     6        0.0405             nan     0.0100    0.0003
     7        0.0398             nan     0.0100    0.0005
     8        0.0392             nan     0.0100    0.0005
     9        0.0387             nan     0.0100    0.0003
    10        0.0381             nan     0.0100    0.0001
    20        0.0335             nan     0.0100    0.0001
    40        0.0249             nan     0.0100    0.0004
    60        0.0190             nan     0.0100    0.0001
    80        0.0146             nan     0.0100    0.0001
   100        0.0114             nan     0.0100    0.0001
   120        0.0089             nan     0.0100    0.0001
   140        0.0070             nan     0.0100    0.0001
   160        0.0054             nan     0.0100    0.0001
   180        0.0043             nan     0.0100    0.0000
   200        0.0034             nan     0.0100    0.0000

- Fold10: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold10: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0433             nan     0.0100    0.0006
     2        0.0426             nan     0.0100    0.0006
     3        0.0420             nan     0.0100    0.0003
     4        0.0414             nan     0.0100    0.0005
     5        0.0409             nan     0.0100    0.0005
     6        0.0401             nan     0.0100    0.0008
     7        0.0396             nan     0.0100    0.0005
     8        0.0390             nan     0.0100    0.0004
     9        0.0384             nan     0.0100    0.0005
    10        0.0380             nan     0.0100    0.0003
    20        0.0328             nan     0.0100    0.0004
    40        0.0256             nan     0.0100    0.0002
    60        0.0201             nan     0.0100   -0.0000
    80        0.0157             nan     0.0100    0.0001
   100        0.0121             nan     0.0100    0.0000
   120        0.0095             nan     0.0100    0.0001
   140        0.0077             nan     0.0100    0.0001
   160        0.0063             nan     0.0100    0.0000
   180        0.0050             nan     0.0100    0.0000
   200        0.0041             nan     0.0100    0.0000

- Fold10: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold10: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0433             nan     0.0100    0.0005
     2        0.0427             nan     0.0100    0.0006
     3        0.0422             nan     0.0100    0.0005
     4        0.0417             nan     0.0100    0.0005
     5        0.0412             nan     0.0100    0.0004
     6        0.0405             nan     0.0100    0.0006
     7        0.0401             nan     0.0100    0.0005
     8        0.0395             nan     0.0100    0.0005
     9        0.0391             nan     0.0100    0.0002
    10        0.0388             nan     0.0100    0.0002
    20        0.0348             nan     0.0100   -0.0000
    40        0.0278             nan     0.0100    0.0000
    60        0.0230             nan     0.0100    0.0002
    80        0.0195             nan     0.0100   -0.0000
   100        0.0163             nan     0.0100    0.0002
   120        0.0137             nan     0.0100    0.0001
   140        0.0118             nan     0.0100    0.0001
   160        0.0102             nan     0.0100    0.0001
   180        0.0089             nan     0.0100    0.0000
   200        0.0078             nan     0.0100    0.0000

- Fold10: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold10: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0410             nan     0.0500    0.0018
     2        0.0402             nan     0.0500   -0.0004
     3        0.0379             nan     0.0500    0.0024
     4        0.0346             nan     0.0500    0.0020
     5        0.0322             nan     0.0500    0.0020
     6        0.0299             nan     0.0500    0.0023
     7        0.0281             nan     0.0500    0.0016
     8        0.0264             nan     0.0500    0.0020
     9        0.0247             nan     0.0500    0.0012
    10        0.0232             nan     0.0500    0.0008
    20        0.0143             nan     0.0500    0.0004
    40        0.0063             nan     0.0500    0.0003
    60        0.0029             nan     0.0500    0.0001
    80        0.0016             nan     0.0500    0.0000
   100        0.0010             nan     0.0500   -0.0000
   120        0.0006             nan     0.0500   -0.0000
   140        0.0004             nan     0.0500   -0.0000
   160        0.0003             nan     0.0500    0.0000
   180        0.0002             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold10: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold10: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0424             nan     0.0500    0.0016
     2        0.0414             nan     0.0500   -0.0014
     3        0.0383             nan     0.0500    0.0028
     4        0.0369             nan     0.0500    0.0010
     5        0.0359             nan     0.0500   -0.0001
     6        0.0335             nan     0.0500    0.0023
     7        0.0317             nan     0.0500    0.0021
     8        0.0295             nan     0.0500    0.0012
     9        0.0282             nan     0.0500    0.0017
    10        0.0269             nan     0.0500    0.0014
    20        0.0174             nan     0.0500    0.0000
    40        0.0070             nan     0.0500    0.0001
    60        0.0040             nan     0.0500    0.0001
    80        0.0021             nan     0.0500    0.0000
   100        0.0012             nan     0.0500    0.0000
   120        0.0007             nan     0.0500    0.0000
   140        0.0005             nan     0.0500    0.0000
   160        0.0003             nan     0.0500   -0.0000
   180        0.0002             nan     0.0500    0.0000
   200        0.0001             nan     0.0500    0.0000

- Fold10: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold10: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0414             nan     0.0500    0.0028
     2        0.0393             nan     0.0500    0.0018
     3        0.0374             nan     0.0500    0.0013
     4        0.0352             nan     0.0500    0.0006
     5        0.0335             nan     0.0500    0.0003
     6        0.0320             nan     0.0500    0.0013
     7        0.0303             nan     0.0500    0.0014
     8        0.0286             nan     0.0500    0.0016
     9        0.0267             nan     0.0500    0.0016
    10        0.0253             nan     0.0500    0.0015
    20        0.0151             nan     0.0500    0.0005
    40        0.0070             nan     0.0500   -0.0000
    60        0.0041             nan     0.0500    0.0000
    80        0.0026             nan     0.0500   -0.0000
   100        0.0017             nan     0.0500   -0.0000
   120        0.0011             nan     0.0500   -0.0000
   140        0.0008             nan     0.0500   -0.0000
   160        0.0006             nan     0.0500   -0.0000
   180        0.0004             nan     0.0500   -0.0000
   200        0.0003             nan     0.0500    0.0000

- Fold10: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold10: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0411             nan     0.0500    0.0023
     2        0.0382             nan     0.0500    0.0027
     3        0.0359             nan     0.0500    0.0018
     4        0.0337             nan     0.0500    0.0021
     5        0.0305             nan     0.0500    0.0030
     6        0.0286             nan     0.0500    0.0022
     7        0.0266             nan     0.0500    0.0013
     8        0.0246             nan     0.0500    0.0016
     9        0.0236             nan     0.0500    0.0008
    10        0.0229             nan     0.0500    0.0002
    20        0.0123             nan     0.0500    0.0007
    40        0.0038             nan     0.0500    0.0001
    60        0.0014             nan     0.0500    0.0000
    80        0.0006             nan     0.0500   -0.0000
   100        0.0003             nan     0.0500   -0.0000
   120        0.0001             nan     0.0500    0.0000
   140        0.0001             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500    0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold10: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold10: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0410             nan     0.0500    0.0021
     2        0.0376             nan     0.0500    0.0023
     3        0.0350             nan     0.0500    0.0012
     4        0.0329             nan     0.0500    0.0018
     5        0.0308             nan     0.0500    0.0022
     6        0.0291             nan     0.0500    0.0014
     7        0.0275             nan     0.0500    0.0000
     8        0.0261             nan     0.0500    0.0010
     9        0.0249             nan     0.0500    0.0010
    10        0.0238             nan     0.0500    0.0008
    20        0.0129             nan     0.0500    0.0001
    40        0.0050             nan     0.0500    0.0001
    60        0.0024             nan     0.0500    0.0000
    80        0.0014             nan     0.0500    0.0000
   100        0.0008             nan     0.0500   -0.0000
   120        0.0005             nan     0.0500   -0.0000
   140        0.0003             nan     0.0500    0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold10: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold10: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0419             nan     0.0500    0.0022
     2        0.0391             nan     0.0500    0.0024
     3        0.0378             nan     0.0500    0.0003
     4        0.0351             nan     0.0500    0.0012
     5        0.0323             nan     0.0500    0.0023
     6        0.0299             nan     0.0500    0.0015
     7        0.0282             nan     0.0500    0.0015
     8        0.0262             nan     0.0500    0.0013
     9        0.0256             nan     0.0500    0.0001
    10        0.0245             nan     0.0500    0.0009
    20        0.0144             nan     0.0500    0.0004
    40        0.0073             nan     0.0500    0.0000
    60        0.0044             nan     0.0500   -0.0000
    80        0.0030             nan     0.0500   -0.0001
   100        0.0020             nan     0.0500   -0.0000
   120        0.0015             nan     0.0500   -0.0000
   140        0.0010             nan     0.0500   -0.0000
   160        0.0008             nan     0.0500   -0.0000
   180        0.0005             nan     0.0500   -0.0000
   200        0.0004             nan     0.0500   -0.0000

- Fold10: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold10: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0402             nan     0.0500    0.0016
     2        0.0368             nan     0.0500    0.0029
     3        0.0351             nan     0.0500    0.0001
     4        0.0329             nan     0.0500    0.0014
     5        0.0314             nan     0.0500    0.0012
     6        0.0295             nan     0.0500    0.0003
     7        0.0271             nan     0.0500    0.0020
     8        0.0254             nan     0.0500    0.0007
     9        0.0234             nan     0.0500    0.0012
    10        0.0218             nan     0.0500    0.0012
    20        0.0124             nan     0.0500   -0.0006
    40        0.0035             nan     0.0500    0.0000
    60        0.0013             nan     0.0500    0.0000
    80        0.0005             nan     0.0500    0.0000
   100        0.0002             nan     0.0500   -0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0000             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500    0.0000

- Fold10: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold10: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0408             nan     0.0500    0.0017
     2        0.0378             nan     0.0500    0.0017
     3        0.0351             nan     0.0500    0.0022
     4        0.0322             nan     0.0500    0.0019
     5        0.0295             nan     0.0500    0.0020
     6        0.0275             nan     0.0500    0.0019
     7        0.0256             nan     0.0500    0.0020
     8        0.0249             nan     0.0500   -0.0001
     9        0.0230             nan     0.0500    0.0012
    10        0.0209             nan     0.0500    0.0014
    20        0.0127             nan     0.0500    0.0005
    40        0.0043             nan     0.0500    0.0001
    60        0.0019             nan     0.0500    0.0001
    80        0.0010             nan     0.0500   -0.0000
   100        0.0005             nan     0.0500   -0.0000
   120        0.0003             nan     0.0500    0.0000
   140        0.0002             nan     0.0500    0.0000
   160        0.0001             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500    0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold10: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold10: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0413             nan     0.0500    0.0026
     2        0.0384             nan     0.0500    0.0010
     3        0.0364             nan     0.0500    0.0019
     4        0.0348             nan     0.0500    0.0016
     5        0.0329             nan     0.0500    0.0022
     6        0.0309             nan     0.0500    0.0018
     7        0.0294             nan     0.0500    0.0015
     8        0.0277             nan     0.0500    0.0017
     9        0.0259             nan     0.0500    0.0017
    10        0.0243             nan     0.0500    0.0004
    20        0.0160             nan     0.0500    0.0005
    40        0.0080             nan     0.0500    0.0000
    60        0.0046             nan     0.0500   -0.0000
    80        0.0028             nan     0.0500   -0.0000
   100        0.0020             nan     0.0500    0.0001
   120        0.0014             nan     0.0500   -0.0000
   140        0.0010             nan     0.0500   -0.0000
   160        0.0007             nan     0.0500   -0.0000
   180        0.0006             nan     0.0500    0.0000
   200        0.0004             nan     0.0500   -0.0000

- Fold10: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold10: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0407             nan     0.1000    0.0030
     2        0.0361             nan     0.1000    0.0044
     3        0.0304             nan     0.1000    0.0031
     4        0.0271             nan     0.1000    0.0028
     5        0.0239             nan     0.1000    0.0026
     6        0.0214             nan     0.1000    0.0009
     7        0.0193             nan     0.1000    0.0022
     8        0.0165             nan     0.1000    0.0022
     9        0.0151             nan     0.1000    0.0006
    10        0.0134             nan     0.1000    0.0014
    20        0.0065             nan     0.1000    0.0000
    40        0.0019             nan     0.1000   -0.0000
    60        0.0008             nan     0.1000   -0.0000
    80        0.0003             nan     0.1000    0.0000
   100        0.0002             nan     0.1000   -0.0000
   120        0.0001             nan     0.1000    0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold10: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold10: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0369             nan     0.1000    0.0036
     2        0.0359             nan     0.1000   -0.0027
     3        0.0312             nan     0.1000    0.0045
     4        0.0278             nan     0.1000    0.0034
     5        0.0258             nan     0.1000    0.0010
     6        0.0226             nan     0.1000    0.0029
     7        0.0201             nan     0.1000    0.0015
     8        0.0186             nan     0.1000    0.0004
     9        0.0172             nan     0.1000    0.0013
    10        0.0147             nan     0.1000    0.0012
    20        0.0059             nan     0.1000    0.0003
    40        0.0018             nan     0.1000   -0.0002
    60        0.0006             nan     0.1000   -0.0001
    80        0.0003             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000    0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold10: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold10: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0381             nan     0.1000    0.0048
     2        0.0335             nan     0.1000    0.0027
     3        0.0292             nan     0.1000    0.0043
     4        0.0262             nan     0.1000    0.0032
     5        0.0228             nan     0.1000    0.0027
     6        0.0203             nan     0.1000    0.0023
     7        0.0179             nan     0.1000    0.0012
     8        0.0159             nan     0.1000    0.0013
     9        0.0146             nan     0.1000    0.0013
    10        0.0134             nan     0.1000    0.0005
    20        0.0072             nan     0.1000   -0.0002
    40        0.0027             nan     0.1000    0.0002
    60        0.0014             nan     0.1000   -0.0001
    80        0.0007             nan     0.1000   -0.0000
   100        0.0003             nan     0.1000   -0.0000
   120        0.0002             nan     0.1000    0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000    0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold10: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold10: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0397             nan     0.1000    0.0047
     2        0.0351             nan     0.1000    0.0051
     3        0.0288             nan     0.1000    0.0061
     4        0.0250             nan     0.1000    0.0030
     5        0.0212             nan     0.1000    0.0036
     6        0.0190             nan     0.1000   -0.0005
     7        0.0160             nan     0.1000    0.0024
     8        0.0135             nan     0.1000    0.0022
     9        0.0117             nan     0.1000    0.0011
    10        0.0101             nan     0.1000    0.0008
    20        0.0038             nan     0.1000    0.0002
    40        0.0005             nan     0.1000    0.0000
    60        0.0001             nan     0.1000    0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold10: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold10: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0371             nan     0.1000    0.0035
     2        0.0331             nan     0.1000    0.0013
     3        0.0280             nan     0.1000    0.0045
     4        0.0251             nan     0.1000    0.0021
     5        0.0226             nan     0.1000    0.0024
     6        0.0202             nan     0.1000    0.0005
     7        0.0165             nan     0.1000    0.0033
     8        0.0147             nan     0.1000    0.0014
     9        0.0133             nan     0.1000    0.0007
    10        0.0122             nan     0.1000   -0.0001
    20        0.0045             nan     0.1000    0.0000
    40        0.0010             nan     0.1000   -0.0000
    60        0.0003             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000    0.0000
   100        0.0000             nan     0.1000    0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000    0.0000

- Fold10: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold10: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0393             nan     0.1000    0.0020
     2        0.0346             nan     0.1000    0.0032
     3        0.0333             nan     0.1000    0.0010
     4        0.0307             nan     0.1000    0.0012
     5        0.0278             nan     0.1000    0.0004
     6        0.0247             nan     0.1000    0.0025
     7        0.0213             nan     0.1000    0.0025
     8        0.0206             nan     0.1000    0.0005
     9        0.0184             nan     0.1000    0.0019
    10        0.0171             nan     0.1000    0.0010
    20        0.0090             nan     0.1000    0.0001
    40        0.0029             nan     0.1000    0.0000
    60        0.0013             nan     0.1000    0.0000
    80        0.0006             nan     0.1000    0.0000
   100        0.0003             nan     0.1000   -0.0000
   120        0.0002             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000    0.0000

- Fold10: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold10: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0381             nan     0.1000    0.0048
     2        0.0331             nan     0.1000    0.0041
     3        0.0274             nan     0.1000    0.0038
     4        0.0228             nan     0.1000    0.0026
     5        0.0195             nan     0.1000    0.0022
     6        0.0166             nan     0.1000    0.0020
     7        0.0147             nan     0.1000    0.0002
     8        0.0123             nan     0.1000    0.0018
     9        0.0108             nan     0.1000   -0.0000
    10        0.0094             nan     0.1000    0.0003
    20        0.0024             nan     0.1000    0.0002
    40        0.0004             nan     0.1000   -0.0000
    60        0.0001             nan     0.1000   -0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold10: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold10: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0400             nan     0.1000    0.0025
     2        0.0353             nan     0.1000    0.0045
     3        0.0294             nan     0.1000    0.0056
     4        0.0255             nan     0.1000    0.0033
     5        0.0229             nan     0.1000    0.0034
     6        0.0205             nan     0.1000    0.0020
     7        0.0184             nan     0.1000    0.0012
     8        0.0162             nan     0.1000    0.0023
     9        0.0147             nan     0.1000    0.0018
    10        0.0134             nan     0.1000    0.0010
    20        0.0044             nan     0.1000    0.0004
    40        0.0007             nan     0.1000   -0.0000
    60        0.0002             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000    0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000    0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold10: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold10: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0380             nan     0.1000    0.0048
     2        0.0350             nan     0.1000    0.0025
     3        0.0304             nan     0.1000    0.0017
     4        0.0265             nan     0.1000    0.0031
     5        0.0231             nan     0.1000    0.0030
     6        0.0223             nan     0.1000   -0.0005
     7        0.0205             nan     0.1000    0.0013
     8        0.0194             nan     0.1000    0.0002
     9        0.0172             nan     0.1000    0.0017
    10        0.0163             nan     0.1000    0.0009
    20        0.0092             nan     0.1000    0.0004
    40        0.0031             nan     0.1000   -0.0001
    60        0.0018             nan     0.1000   -0.0000
    80        0.0009             nan     0.1000    0.0000
   100        0.0005             nan     0.1000   -0.0000
   120        0.0003             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000    0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold10: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold11: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0424             nan     0.0100    0.0005
     2        0.0419             nan     0.0100    0.0004
     3        0.0413             nan     0.0100    0.0005
     4        0.0410             nan     0.0100    0.0000
     5        0.0404             nan     0.0100    0.0005
     6        0.0400             nan     0.0100    0.0001
     7        0.0396             nan     0.0100    0.0003
     8        0.0392             nan     0.0100    0.0003
     9        0.0389             nan     0.0100    0.0003
    10        0.0384             nan     0.0100    0.0005
    20        0.0339             nan     0.0100    0.0003
    40        0.0273             nan     0.0100    0.0002
    60        0.0223             nan     0.0100    0.0002
    80        0.0185             nan     0.0100   -0.0000
   100        0.0153             nan     0.0100    0.0002
   120        0.0126             nan     0.0100   -0.0000
   140        0.0106             nan     0.0100    0.0001
   160        0.0090             nan     0.0100   -0.0000
   180        0.0077             nan     0.0100    0.0000
   200        0.0066             nan     0.0100    0.0000

- Fold11: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold11: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0425             nan     0.0100    0.0003
     2        0.0421             nan     0.0100    0.0002
     3        0.0418             nan     0.0100    0.0002
     4        0.0413             nan     0.0100    0.0001
     5        0.0408             nan     0.0100    0.0005
     6        0.0402             nan     0.0100    0.0005
     7        0.0396             nan     0.0100    0.0006
     8        0.0391             nan     0.0100    0.0005
     9        0.0386             nan     0.0100    0.0003
    10        0.0381             nan     0.0100    0.0003
    20        0.0343             nan     0.0100    0.0002
    40        0.0265             nan     0.0100    0.0003
    60        0.0214             nan     0.0100    0.0001
    80        0.0173             nan     0.0100    0.0000
   100        0.0144             nan     0.0100    0.0000
   120        0.0119             nan     0.0100    0.0000
   140        0.0100             nan     0.0100    0.0000
   160        0.0083             nan     0.0100    0.0001
   180        0.0070             nan     0.0100    0.0000
   200        0.0060             nan     0.0100   -0.0000

- Fold11: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold11: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0426             nan     0.0100    0.0003
     2        0.0421             nan     0.0100    0.0004
     3        0.0415             nan     0.0100    0.0005
     4        0.0411             nan     0.0100    0.0002
     5        0.0407             nan     0.0100    0.0004
     6        0.0403             nan     0.0100    0.0004
     7        0.0398             nan     0.0100    0.0005
     8        0.0393             nan     0.0100    0.0005
     9        0.0388             nan     0.0100    0.0004
    10        0.0384             nan     0.0100    0.0003
    20        0.0340             nan     0.0100    0.0002
    40        0.0277             nan     0.0100    0.0003
    60        0.0224             nan     0.0100    0.0001
    80        0.0187             nan     0.0100    0.0001
   100        0.0154             nan     0.0100    0.0001
   120        0.0133             nan     0.0100    0.0001
   140        0.0116             nan     0.0100    0.0000
   160        0.0102             nan     0.0100    0.0001
   180        0.0090             nan     0.0100    0.0001
   200        0.0081             nan     0.0100    0.0000

- Fold11: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold11: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0422             nan     0.0100    0.0006
     2        0.0414             nan     0.0100    0.0008
     3        0.0409             nan     0.0100    0.0005
     4        0.0406             nan     0.0100   -0.0000
     5        0.0403             nan     0.0100    0.0001
     6        0.0394             nan     0.0100    0.0004
     7        0.0390             nan     0.0100    0.0005
     8        0.0382             nan     0.0100    0.0008
     9        0.0374             nan     0.0100    0.0005
    10        0.0371             nan     0.0100   -0.0000
    20        0.0322             nan     0.0100    0.0006
    40        0.0240             nan     0.0100    0.0002
    60        0.0185             nan     0.0100    0.0001
    80        0.0145             nan     0.0100    0.0001
   100        0.0114             nan     0.0100    0.0002
   120        0.0090             nan     0.0100    0.0000
   140        0.0071             nan     0.0100    0.0000
   160        0.0056             nan     0.0100    0.0000
   180        0.0045             nan     0.0100    0.0000
   200        0.0036             nan     0.0100    0.0000

- Fold11: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold11: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0424             nan     0.0100    0.0006
     2        0.0417             nan     0.0100    0.0007
     3        0.0411             nan     0.0100    0.0005
     4        0.0405             nan     0.0100    0.0005
     5        0.0399             nan     0.0100    0.0003
     6        0.0394             nan     0.0100    0.0006
     7        0.0388             nan     0.0100    0.0005
     8        0.0383             nan     0.0100    0.0004
     9        0.0377             nan     0.0100    0.0002
    10        0.0371             nan     0.0100    0.0004
    20        0.0326             nan     0.0100    0.0004
    40        0.0255             nan     0.0100    0.0002
    60        0.0200             nan     0.0100    0.0002
    80        0.0159             nan     0.0100    0.0002
   100        0.0129             nan     0.0100    0.0000
   120        0.0106             nan     0.0100    0.0000
   140        0.0085             nan     0.0100   -0.0000
   160        0.0071             nan     0.0100    0.0001
   180        0.0058             nan     0.0100   -0.0000
   200        0.0048             nan     0.0100    0.0001

- Fold11: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold11: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0426             nan     0.0100    0.0004
     2        0.0421             nan     0.0100    0.0003
     3        0.0418             nan     0.0100    0.0001
     4        0.0415             nan     0.0100    0.0001
     5        0.0412             nan     0.0100   -0.0000
     6        0.0405             nan     0.0100    0.0006
     7        0.0403             nan     0.0100    0.0000
     8        0.0396             nan     0.0100    0.0003
     9        0.0393             nan     0.0100   -0.0000
    10        0.0389             nan     0.0100    0.0002
    20        0.0344             nan     0.0100    0.0004
    40        0.0276             nan     0.0100    0.0002
    60        0.0227             nan     0.0100    0.0001
    80        0.0190             nan     0.0100    0.0002
   100        0.0164             nan     0.0100    0.0001
   120        0.0141             nan     0.0100   -0.0000
   140        0.0120             nan     0.0100    0.0001
   160        0.0103             nan     0.0100    0.0001
   180        0.0092             nan     0.0100    0.0000
   200        0.0082             nan     0.0100   -0.0000

- Fold11: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold11: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0426             nan     0.0100    0.0005
     2        0.0419             nan     0.0100    0.0003
     3        0.0413             nan     0.0100    0.0003
     4        0.0406             nan     0.0100    0.0009
     5        0.0398             nan     0.0100    0.0005
     6        0.0393             nan     0.0100    0.0002
     7        0.0388             nan     0.0100    0.0004
     8        0.0382             nan     0.0100    0.0005
     9        0.0377             nan     0.0100    0.0002
    10        0.0373             nan     0.0100    0.0004
    20        0.0320             nan     0.0100    0.0005
    40        0.0233             nan     0.0100    0.0002
    60        0.0178             nan     0.0100    0.0002
    80        0.0134             nan     0.0100    0.0001
   100        0.0103             nan     0.0100    0.0000
   120        0.0081             nan     0.0100    0.0000
   140        0.0063             nan     0.0100    0.0000
   160        0.0051             nan     0.0100   -0.0000
   180        0.0041             nan     0.0100    0.0000
   200        0.0032             nan     0.0100    0.0000

- Fold11: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold11: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0423             nan     0.0100    0.0005
     2        0.0415             nan     0.0100    0.0006
     3        0.0409             nan     0.0100    0.0006
     4        0.0402             nan     0.0100    0.0007
     5        0.0396             nan     0.0100    0.0004
     6        0.0391             nan     0.0100    0.0004
     7        0.0384             nan     0.0100    0.0002
     8        0.0379             nan     0.0100    0.0004
     9        0.0374             nan     0.0100    0.0002
    10        0.0368             nan     0.0100    0.0005
    20        0.0322             nan     0.0100    0.0003
    40        0.0241             nan     0.0100    0.0003
    60        0.0184             nan     0.0100    0.0002
    80        0.0144             nan     0.0100    0.0002
   100        0.0116             nan     0.0100    0.0001
   120        0.0091             nan     0.0100    0.0001
   140        0.0076             nan     0.0100    0.0001
   160        0.0062             nan     0.0100    0.0001
   180        0.0050             nan     0.0100    0.0000
   200        0.0041             nan     0.0100    0.0000

- Fold11: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold11: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0425             nan     0.0100    0.0004
     2        0.0421             nan     0.0100    0.0003
     3        0.0416             nan     0.0100    0.0005
     4        0.0410             nan     0.0100    0.0004
     5        0.0407             nan     0.0100    0.0001
     6        0.0401             nan     0.0100    0.0006
     7        0.0397             nan     0.0100    0.0003
     8        0.0394             nan     0.0100    0.0003
     9        0.0390             nan     0.0100    0.0002
    10        0.0386             nan     0.0100    0.0005
    20        0.0342             nan     0.0100    0.0001
    40        0.0278             nan     0.0100    0.0002
    60        0.0225             nan     0.0100    0.0002
    80        0.0188             nan     0.0100    0.0001
   100        0.0157             nan     0.0100    0.0000
   120        0.0134             nan     0.0100    0.0001
   140        0.0115             nan     0.0100    0.0001
   160        0.0101             nan     0.0100    0.0000
   180        0.0088             nan     0.0100    0.0000
   200        0.0079             nan     0.0100    0.0000

- Fold11: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold11: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0398             nan     0.0500    0.0028
     2        0.0371             nan     0.0500    0.0026
     3        0.0353             nan     0.0500    0.0001
     4        0.0326             nan     0.0500    0.0022
     5        0.0306             nan     0.0500    0.0013
     6        0.0291             nan     0.0500    0.0014
     7        0.0280             nan     0.0500    0.0001
     8        0.0263             nan     0.0500    0.0011
     9        0.0247             nan     0.0500    0.0017
    10        0.0237             nan     0.0500    0.0007
    20        0.0143             nan     0.0500   -0.0002
    40        0.0062             nan     0.0500    0.0001
    60        0.0031             nan     0.0500   -0.0001
    80        0.0016             nan     0.0500    0.0000
   100        0.0010             nan     0.0500    0.0000
   120        0.0006             nan     0.0500   -0.0000
   140        0.0003             nan     0.0500    0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500    0.0000

- Fold11: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold11: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0404             nan     0.0500    0.0025
     2        0.0383             nan     0.0500    0.0022
     3        0.0362             nan     0.0500    0.0006
     4        0.0354             nan     0.0500    0.0001
     5        0.0345             nan     0.0500    0.0001
     6        0.0330             nan     0.0500    0.0003
     7        0.0309             nan     0.0500    0.0013
     8        0.0301             nan     0.0500    0.0000
     9        0.0286             nan     0.0500    0.0012
    10        0.0270             nan     0.0500    0.0017
    20        0.0158             nan     0.0500    0.0003
    40        0.0069             nan     0.0500    0.0000
    60        0.0033             nan     0.0500    0.0001
    80        0.0018             nan     0.0500    0.0001
   100        0.0012             nan     0.0500    0.0000
   120        0.0008             nan     0.0500    0.0000
   140        0.0005             nan     0.0500   -0.0000
   160        0.0003             nan     0.0500    0.0000
   180        0.0002             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500    0.0000

- Fold11: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold11: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0397             nan     0.0500    0.0025
     2        0.0379             nan     0.0500    0.0001
     3        0.0350             nan     0.0500    0.0024
     4        0.0331             nan     0.0500    0.0021
     5        0.0312             nan     0.0500    0.0011
     6        0.0293             nan     0.0500    0.0012
     7        0.0273             nan     0.0500    0.0013
     8        0.0257             nan     0.0500    0.0015
     9        0.0238             nan     0.0500    0.0013
    10        0.0224             nan     0.0500    0.0012
    20        0.0146             nan     0.0500    0.0002
    40        0.0072             nan     0.0500   -0.0001
    60        0.0038             nan     0.0500    0.0001
    80        0.0025             nan     0.0500    0.0000
   100        0.0016             nan     0.0500   -0.0000
   120        0.0011             nan     0.0500    0.0000
   140        0.0008             nan     0.0500   -0.0000
   160        0.0006             nan     0.0500    0.0000
   180        0.0004             nan     0.0500   -0.0000
   200        0.0003             nan     0.0500    0.0000

- Fold11: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold11: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0400             nan     0.0500    0.0021
     2        0.0372             nan     0.0500    0.0015
     3        0.0343             nan     0.0500    0.0015
     4        0.0313             nan     0.0500    0.0024
     5        0.0287             nan     0.0500    0.0012
     6        0.0269             nan     0.0500    0.0011
     7        0.0251             nan     0.0500    0.0012
     8        0.0232             nan     0.0500    0.0013
     9        0.0222             nan     0.0500    0.0002
    10        0.0214             nan     0.0500    0.0000
    20        0.0114             nan     0.0500    0.0007
    40        0.0042             nan     0.0500    0.0001
    60        0.0015             nan     0.0500   -0.0000
    80        0.0008             nan     0.0500   -0.0000
   100        0.0003             nan     0.0500    0.0000
   120        0.0002             nan     0.0500   -0.0000
   140        0.0001             nan     0.0500    0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold11: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold11: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0402             nan     0.0500    0.0013
     2        0.0372             nan     0.0500    0.0024
     3        0.0345             nan     0.0500    0.0028
     4        0.0319             nan     0.0500    0.0025
     5        0.0305             nan     0.0500   -0.0002
     6        0.0292             nan     0.0500    0.0005
     7        0.0268             nan     0.0500    0.0010
     8        0.0250             nan     0.0500    0.0012
     9        0.0226             nan     0.0500    0.0015
    10        0.0206             nan     0.0500    0.0014
    20        0.0111             nan     0.0500    0.0000
    40        0.0040             nan     0.0500    0.0001
    60        0.0017             nan     0.0500   -0.0000
    80        0.0008             nan     0.0500    0.0000
   100        0.0005             nan     0.0500   -0.0000
   120        0.0003             nan     0.0500    0.0000
   140        0.0002             nan     0.0500   -0.0000
   160        0.0001             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold11: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold11: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0405             nan     0.0500    0.0020
     2        0.0378             nan     0.0500    0.0023
     3        0.0352             nan     0.0500    0.0022
     4        0.0330             nan     0.0500    0.0020
     5        0.0308             nan     0.0500    0.0019
     6        0.0292             nan     0.0500    0.0013
     7        0.0271             nan     0.0500    0.0017
     8        0.0254             nan     0.0500    0.0004
     9        0.0237             nan     0.0500    0.0010
    10        0.0229             nan     0.0500   -0.0008
    20        0.0143             nan     0.0500    0.0001
    40        0.0072             nan     0.0500    0.0001
    60        0.0040             nan     0.0500    0.0001
    80        0.0027             nan     0.0500    0.0000
   100        0.0020             nan     0.0500    0.0000
   120        0.0015             nan     0.0500   -0.0000
   140        0.0011             nan     0.0500   -0.0000
   160        0.0008             nan     0.0500    0.0000
   180        0.0006             nan     0.0500   -0.0000
   200        0.0005             nan     0.0500   -0.0000

- Fold11: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold11: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0396             nan     0.0500    0.0033
     2        0.0367             nan     0.0500    0.0020
     3        0.0330             nan     0.0500    0.0022
     4        0.0299             nan     0.0500    0.0023
     5        0.0278             nan     0.0500    0.0022
     6        0.0255             nan     0.0500    0.0021
     7        0.0239             nan     0.0500    0.0014
     8        0.0217             nan     0.0500    0.0025
     9        0.0201             nan     0.0500    0.0014
    10        0.0185             nan     0.0500    0.0010
    20        0.0098             nan     0.0500    0.0003
    40        0.0029             nan     0.0500   -0.0000
    60        0.0013             nan     0.0500    0.0001
    80        0.0005             nan     0.0500   -0.0000
   100        0.0002             nan     0.0500   -0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0001             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500    0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold11: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold11: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0404             nan     0.0500    0.0024
     2        0.0370             nan     0.0500    0.0029
     3        0.0343             nan     0.0500    0.0021
     4        0.0320             nan     0.0500    0.0022
     5        0.0300             nan     0.0500    0.0016
     6        0.0281             nan     0.0500    0.0020
     7        0.0268             nan     0.0500   -0.0002
     8        0.0245             nan     0.0500    0.0014
     9        0.0230             nan     0.0500    0.0005
    10        0.0218             nan     0.0500    0.0005
    20        0.0129             nan     0.0500   -0.0004
    40        0.0045             nan     0.0500    0.0001
    60        0.0021             nan     0.0500    0.0000
    80        0.0009             nan     0.0500    0.0000
   100        0.0006             nan     0.0500   -0.0000
   120        0.0004             nan     0.0500   -0.0000
   140        0.0003             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500    0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold11: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold11: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0405             nan     0.0500    0.0026
     2        0.0392             nan     0.0500    0.0005
     3        0.0373             nan     0.0500    0.0024
     4        0.0351             nan     0.0500    0.0016
     5        0.0328             nan     0.0500    0.0012
     6        0.0304             nan     0.0500    0.0021
     7        0.0289             nan     0.0500    0.0017
     8        0.0271             nan     0.0500    0.0014
     9        0.0264             nan     0.0500    0.0004
    10        0.0249             nan     0.0500    0.0014
    20        0.0161             nan     0.0500    0.0008
    40        0.0085             nan     0.0500    0.0001
    60        0.0048             nan     0.0500   -0.0001
    80        0.0030             nan     0.0500   -0.0000
   100        0.0019             nan     0.0500   -0.0000
   120        0.0014             nan     0.0500   -0.0000
   140        0.0010             nan     0.0500    0.0000
   160        0.0007             nan     0.0500   -0.0000
   180        0.0005             nan     0.0500   -0.0000
   200        0.0004             nan     0.0500   -0.0000

- Fold11: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold11: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0364             nan     0.1000    0.0054
     2        0.0315             nan     0.1000    0.0034
     3        0.0266             nan     0.1000    0.0023
     4        0.0255             nan     0.1000   -0.0011
     5        0.0247             nan     0.1000   -0.0017
     6        0.0217             nan     0.1000    0.0023
     7        0.0191             nan     0.1000    0.0012
     8        0.0171             nan     0.1000    0.0012
     9        0.0148             nan     0.1000    0.0019
    10        0.0137             nan     0.1000    0.0000
    20        0.0055             nan     0.1000   -0.0000
    40        0.0014             nan     0.1000   -0.0001
    60        0.0005             nan     0.1000    0.0000
    80        0.0002             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000    0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000    0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold11: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold11: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0397             nan     0.1000    0.0020
     2        0.0345             nan     0.1000    0.0040
     3        0.0304             nan     0.1000    0.0039
     4        0.0280             nan     0.1000    0.0005
     5        0.0246             nan     0.1000    0.0033
     6        0.0223             nan     0.1000    0.0012
     7        0.0205             nan     0.1000    0.0007
     8        0.0183             nan     0.1000    0.0012
     9        0.0169             nan     0.1000    0.0018
    10        0.0147             nan     0.1000    0.0011
    20        0.0064             nan     0.1000   -0.0000
    40        0.0023             nan     0.1000   -0.0002
    60        0.0009             nan     0.1000   -0.0000
    80        0.0005             nan     0.1000   -0.0000
   100        0.0002             nan     0.1000    0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold11: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold11: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0380             nan     0.1000    0.0050
     2        0.0333             nan     0.1000    0.0019
     3        0.0303             nan     0.1000    0.0015
     4        0.0276             nan     0.1000    0.0032
     5        0.0246             nan     0.1000    0.0030
     6        0.0219             nan     0.1000    0.0025
     7        0.0195             nan     0.1000    0.0019
     8        0.0182             nan     0.1000    0.0007
     9        0.0167             nan     0.1000    0.0015
    10        0.0160             nan     0.1000    0.0002
    20        0.0079             nan     0.1000    0.0005
    40        0.0032             nan     0.1000   -0.0001
    60        0.0015             nan     0.1000   -0.0001
    80        0.0010             nan     0.1000   -0.0001
   100        0.0005             nan     0.1000   -0.0000
   120        0.0004             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold11: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold11: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0367             nan     0.1000    0.0028
     2        0.0305             nan     0.1000    0.0058
     3        0.0274             nan     0.1000    0.0029
     4        0.0233             nan     0.1000    0.0018
     5        0.0212             nan     0.1000    0.0015
     6        0.0190             nan     0.1000    0.0017
     7        0.0167             nan     0.1000    0.0022
     8        0.0144             nan     0.1000    0.0026
     9        0.0128             nan     0.1000    0.0000
    10        0.0110             nan     0.1000    0.0011
    20        0.0032             nan     0.1000    0.0003
    40        0.0004             nan     0.1000    0.0000
    60        0.0001             nan     0.1000   -0.0000
    80        0.0000             nan     0.1000    0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000    0.0000
   160        0.0000             nan     0.1000    0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold11: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold11: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0377             nan     0.1000    0.0062
     2        0.0330             nan     0.1000    0.0042
     3        0.0297             nan     0.1000    0.0029
     4        0.0275             nan     0.1000    0.0007
     5        0.0243             nan     0.1000    0.0005
     6        0.0214             nan     0.1000    0.0029
     7        0.0182             nan     0.1000    0.0014
     8        0.0160             nan     0.1000    0.0014
     9        0.0146             nan     0.1000    0.0010
    10        0.0131             nan     0.1000    0.0011
    20        0.0039             nan     0.1000   -0.0000
    40        0.0009             nan     0.1000    0.0001
    60        0.0003             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000    0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold11: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold11: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0381             nan     0.1000    0.0047
     2        0.0365             nan     0.1000   -0.0012
     3        0.0332             nan     0.1000    0.0034
     4        0.0289             nan     0.1000    0.0039
     5        0.0249             nan     0.1000    0.0036
     6        0.0235             nan     0.1000    0.0015
     7        0.0205             nan     0.1000    0.0006
     8        0.0184             nan     0.1000    0.0019
     9        0.0164             nan     0.1000    0.0018
    10        0.0147             nan     0.1000    0.0015
    20        0.0072             nan     0.1000    0.0003
    40        0.0027             nan     0.1000    0.0001
    60        0.0011             nan     0.1000    0.0000
    80        0.0006             nan     0.1000   -0.0000
   100        0.0003             nan     0.1000   -0.0000
   120        0.0002             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold11: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold11: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0383             nan     0.1000    0.0019
     2        0.0337             nan     0.1000    0.0005
     3        0.0300             nan     0.1000    0.0019
     4        0.0287             nan     0.1000   -0.0007
     5        0.0247             nan     0.1000    0.0013
     6        0.0207             nan     0.1000    0.0031
     7        0.0183             nan     0.1000    0.0025
     8        0.0152             nan     0.1000    0.0027
     9        0.0139             nan     0.1000   -0.0005
    10        0.0125             nan     0.1000    0.0003
    20        0.0045             nan     0.1000    0.0004
    40        0.0006             nan     0.1000   -0.0001
    60        0.0002             nan     0.1000   -0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000    0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold11: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold11: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0366             nan     0.1000    0.0058
     2        0.0335             nan     0.1000    0.0015
     3        0.0278             nan     0.1000    0.0042
     4        0.0246             nan     0.1000    0.0026
     5        0.0213             nan     0.1000    0.0024
     6        0.0193             nan     0.1000    0.0010
     7        0.0169             nan     0.1000    0.0015
     8        0.0145             nan     0.1000    0.0004
     9        0.0128             nan     0.1000    0.0017
    10        0.0121             nan     0.1000    0.0003
    20        0.0038             nan     0.1000    0.0001
    40        0.0011             nan     0.1000   -0.0001
    60        0.0002             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000    0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold11: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold11: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0369             nan     0.1000    0.0048
     2        0.0335             nan     0.1000    0.0014
     3        0.0301             nan     0.1000    0.0039
     4        0.0267             nan     0.1000    0.0030
     5        0.0236             nan     0.1000    0.0001
     6        0.0218             nan     0.1000    0.0013
     7        0.0202             nan     0.1000   -0.0004
     8        0.0194             nan     0.1000   -0.0002
     9        0.0175             nan     0.1000    0.0010
    10        0.0157             nan     0.1000    0.0013
    20        0.0088             nan     0.1000    0.0003
    40        0.0041             nan     0.1000    0.0002
    60        0.0019             nan     0.1000    0.0001
    80        0.0009             nan     0.1000   -0.0000
   100        0.0005             nan     0.1000    0.0000
   120        0.0003             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold11: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold12: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0435             nan     0.0100    0.0005
     2        0.0432             nan     0.0100    0.0001
     3        0.0426             nan     0.0100    0.0005
     4        0.0419             nan     0.0100    0.0005
     5        0.0414             nan     0.0100    0.0006
     6        0.0411             nan     0.0100    0.0001
     7        0.0405             nan     0.0100    0.0005
     8        0.0403             nan     0.0100   -0.0000
     9        0.0400             nan     0.0100   -0.0000
    10        0.0396             nan     0.0100    0.0001
    20        0.0347             nan     0.0100    0.0004
    40        0.0273             nan     0.0100    0.0003
    60        0.0222             nan     0.0100    0.0002
    80        0.0179             nan     0.0100    0.0002
   100        0.0147             nan     0.0100    0.0001
   120        0.0126             nan     0.0100    0.0000
   140        0.0103             nan     0.0100    0.0000
   160        0.0088             nan     0.0100    0.0000
   180        0.0075             nan     0.0100    0.0000
   200        0.0063             nan     0.0100    0.0000

- Fold12: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold12: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0436             nan     0.0100    0.0003
     2        0.0430             nan     0.0100    0.0006
     3        0.0425             nan     0.0100    0.0005
     4        0.0418             nan     0.0100    0.0005
     5        0.0415             nan     0.0100    0.0001
     6        0.0410             nan     0.0100    0.0005
     7        0.0403             nan     0.0100    0.0004
     8        0.0397             nan     0.0100    0.0005
     9        0.0394             nan     0.0100    0.0003
    10        0.0388             nan     0.0100    0.0004
    20        0.0343             nan     0.0100    0.0005
    40        0.0275             nan     0.0100    0.0003
    60        0.0218             nan     0.0100    0.0002
    80        0.0179             nan     0.0100    0.0002
   100        0.0146             nan     0.0100   -0.0000
   120        0.0123             nan     0.0100    0.0001
   140        0.0105             nan     0.0100    0.0000
   160        0.0088             nan     0.0100    0.0000
   180        0.0073             nan     0.0100    0.0001
   200        0.0064             nan     0.0100   -0.0001

- Fold12: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold12: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0433             nan     0.0100    0.0005
     2        0.0431             nan     0.0100   -0.0001
     3        0.0426             nan     0.0100    0.0006
     4        0.0421             nan     0.0100    0.0004
     5        0.0415             nan     0.0100    0.0005
     6        0.0412             nan     0.0100    0.0000
     7        0.0408             nan     0.0100    0.0003
     8        0.0404             nan     0.0100    0.0003
     9        0.0399             nan     0.0100    0.0005
    10        0.0393             nan     0.0100    0.0004
    20        0.0349             nan     0.0100    0.0005
    40        0.0283             nan     0.0100    0.0000
    60        0.0234             nan     0.0100    0.0002
    80        0.0191             nan     0.0100    0.0002
   100        0.0160             nan     0.0100    0.0002
   120        0.0136             nan     0.0100   -0.0000
   140        0.0112             nan     0.0100   -0.0001
   160        0.0099             nan     0.0100    0.0000
   180        0.0086             nan     0.0100   -0.0000
   200        0.0077             nan     0.0100    0.0000

- Fold12: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold12: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0433             nan     0.0100    0.0007
     2        0.0430             nan     0.0100    0.0001
     3        0.0427             nan     0.0100   -0.0001
     4        0.0419             nan     0.0100    0.0008
     5        0.0413             nan     0.0100    0.0000
     6        0.0405             nan     0.0100    0.0006
     7        0.0397             nan     0.0100    0.0007
     8        0.0393             nan     0.0100    0.0005
     9        0.0389             nan     0.0100    0.0002
    10        0.0383             nan     0.0100    0.0005
    20        0.0338             nan     0.0100    0.0003
    40        0.0253             nan     0.0100    0.0002
    60        0.0195             nan     0.0100    0.0002
    80        0.0150             nan     0.0100   -0.0000
   100        0.0117             nan     0.0100    0.0000
   120        0.0091             nan     0.0100   -0.0000
   140        0.0073             nan     0.0100    0.0000
   160        0.0058             nan     0.0100    0.0000
   180        0.0049             nan     0.0100    0.0000
   200        0.0039             nan     0.0100   -0.0000

- Fold12: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold12: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0433             nan     0.0100    0.0006
     2        0.0427             nan     0.0100    0.0004
     3        0.0420             nan     0.0100    0.0005
     4        0.0415             nan     0.0100    0.0002
     5        0.0409             nan     0.0100    0.0004
     6        0.0405             nan     0.0100    0.0005
     7        0.0399             nan     0.0100    0.0007
     8        0.0394             nan     0.0100    0.0004
     9        0.0389             nan     0.0100    0.0004
    10        0.0384             nan     0.0100    0.0004
    20        0.0335             nan     0.0100    0.0003
    40        0.0255             nan     0.0100    0.0003
    60        0.0198             nan     0.0100    0.0001
    80        0.0157             nan     0.0100    0.0000
   100        0.0125             nan     0.0100    0.0001
   120        0.0103             nan     0.0100    0.0000
   140        0.0080             nan     0.0100    0.0001
   160        0.0065             nan     0.0100    0.0001
   180        0.0052             nan     0.0100   -0.0000
   200        0.0044             nan     0.0100    0.0000

- Fold12: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold12: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0435             nan     0.0100    0.0005
     2        0.0429             nan     0.0100    0.0006
     3        0.0423             nan     0.0100    0.0005
     4        0.0419             nan     0.0100    0.0006
     5        0.0413             nan     0.0100    0.0005
     6        0.0406             nan     0.0100    0.0005
     7        0.0401             nan     0.0100    0.0005
     8        0.0397             nan     0.0100    0.0002
     9        0.0393             nan     0.0100    0.0002
    10        0.0387             nan     0.0100    0.0004
    20        0.0344             nan     0.0100    0.0002
    40        0.0277             nan     0.0100    0.0003
    60        0.0225             nan     0.0100    0.0001
    80        0.0187             nan     0.0100    0.0001
   100        0.0154             nan     0.0100    0.0001
   120        0.0133             nan     0.0100    0.0001
   140        0.0115             nan     0.0100    0.0001
   160        0.0102             nan     0.0100    0.0001
   180        0.0091             nan     0.0100    0.0001
   200        0.0079             nan     0.0100    0.0000

- Fold12: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold12: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0435             nan     0.0100    0.0004
     2        0.0430             nan     0.0100    0.0001
     3        0.0424             nan     0.0100    0.0004
     4        0.0419             nan     0.0100    0.0005
     5        0.0415             nan     0.0100    0.0005
     6        0.0409             nan     0.0100    0.0004
     7        0.0402             nan     0.0100    0.0004
     8        0.0396             nan     0.0100    0.0004
     9        0.0389             nan     0.0100    0.0007
    10        0.0384             nan     0.0100    0.0003
    20        0.0333             nan     0.0100    0.0005
    40        0.0249             nan     0.0100    0.0002
    60        0.0181             nan     0.0100    0.0002
    80        0.0137             nan     0.0100    0.0001
   100        0.0104             nan     0.0100    0.0001
   120        0.0079             nan     0.0100    0.0000
   140        0.0062             nan     0.0100   -0.0000
   160        0.0049             nan     0.0100    0.0000
   180        0.0039             nan     0.0100    0.0000
   200        0.0032             nan     0.0100    0.0000

- Fold12: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold12: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0434             nan     0.0100    0.0005
     2        0.0426             nan     0.0100    0.0006
     3        0.0421             nan     0.0100    0.0004
     4        0.0413             nan     0.0100    0.0004
     5        0.0408             nan     0.0100    0.0006
     6        0.0401             nan     0.0100    0.0004
     7        0.0395             nan     0.0100    0.0004
     8        0.0389             nan     0.0100    0.0002
     9        0.0383             nan     0.0100    0.0006
    10        0.0379             nan     0.0100    0.0003
    20        0.0324             nan     0.0100    0.0005
    40        0.0244             nan     0.0100    0.0003
    60        0.0189             nan     0.0100    0.0003
    80        0.0143             nan     0.0100    0.0001
   100        0.0112             nan     0.0100    0.0000
   120        0.0088             nan     0.0100    0.0001
   140        0.0071             nan     0.0100    0.0000
   160        0.0057             nan     0.0100    0.0000
   180        0.0046             nan     0.0100    0.0000
   200        0.0039             nan     0.0100   -0.0000

- Fold12: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold12: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0433             nan     0.0100    0.0005
     2        0.0429             nan     0.0100    0.0002
     3        0.0424             nan     0.0100    0.0006
     4        0.0416             nan     0.0100    0.0006
     5        0.0413             nan     0.0100    0.0001
     6        0.0409             nan     0.0100    0.0002
     7        0.0404             nan     0.0100    0.0005
     8        0.0400             nan     0.0100    0.0003
     9        0.0396             nan     0.0100    0.0005
    10        0.0391             nan     0.0100    0.0002
    20        0.0349             nan     0.0100    0.0003
    40        0.0281             nan     0.0100    0.0003
    60        0.0230             nan     0.0100   -0.0001
    80        0.0187             nan     0.0100    0.0001
   100        0.0157             nan     0.0100    0.0001
   120        0.0132             nan     0.0100   -0.0000
   140        0.0114             nan     0.0100   -0.0000
   160        0.0099             nan     0.0100    0.0000
   180        0.0088             nan     0.0100    0.0001
   200        0.0078             nan     0.0100    0.0000

- Fold12: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold12: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0430             nan     0.0500   -0.0009
     2        0.0410             nan     0.0500    0.0017
     3        0.0385             nan     0.0500    0.0028
     4        0.0354             nan     0.0500    0.0021
     5        0.0334             nan     0.0500    0.0014
     6        0.0311             nan     0.0500    0.0020
     7        0.0298             nan     0.0500   -0.0001
     8        0.0286             nan     0.0500    0.0005
     9        0.0265             nan     0.0500    0.0018
    10        0.0248             nan     0.0500    0.0014
    20        0.0136             nan     0.0500    0.0005
    40        0.0055             nan     0.0500   -0.0000
    60        0.0030             nan     0.0500   -0.0000
    80        0.0016             nan     0.0500    0.0000
   100        0.0010             nan     0.0500   -0.0000
   120        0.0006             nan     0.0500    0.0000
   140        0.0003             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500    0.0000
   180        0.0001             nan     0.0500    0.0000
   200        0.0001             nan     0.0500    0.0000

- Fold12: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold12: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0417             nan     0.0500    0.0022
     2        0.0392             nan     0.0500    0.0021
     3        0.0368             nan     0.0500    0.0005
     4        0.0350             nan     0.0500    0.0001
     5        0.0333             nan     0.0500    0.0014
     6        0.0309             nan     0.0500    0.0021
     7        0.0290             nan     0.0500    0.0010
     8        0.0272             nan     0.0500    0.0017
     9        0.0261             nan     0.0500    0.0006
    10        0.0244             nan     0.0500    0.0015
    20        0.0144             nan     0.0500   -0.0004
    40        0.0061             nan     0.0500    0.0002
    60        0.0032             nan     0.0500    0.0000
    80        0.0017             nan     0.0500    0.0001
   100        0.0009             nan     0.0500    0.0000
   120        0.0006             nan     0.0500   -0.0000
   140        0.0003             nan     0.0500    0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold12: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold12: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0433             nan     0.0500   -0.0008
     2        0.0407             nan     0.0500    0.0026
     3        0.0387             nan     0.0500    0.0015
     4        0.0367             nan     0.0500    0.0024
     5        0.0341             nan     0.0500    0.0010
     6        0.0319             nan     0.0500    0.0005
     7        0.0303             nan     0.0500    0.0009
     8        0.0286             nan     0.0500    0.0019
     9        0.0267             nan     0.0500    0.0014
    10        0.0259             nan     0.0500    0.0004
    20        0.0156             nan     0.0500    0.0007
    40        0.0080             nan     0.0500    0.0001
    60        0.0049             nan     0.0500    0.0001
    80        0.0034             nan     0.0500   -0.0001
   100        0.0023             nan     0.0500   -0.0000
   120        0.0017             nan     0.0500   -0.0001
   140        0.0013             nan     0.0500    0.0000
   160        0.0010             nan     0.0500   -0.0000
   180        0.0008             nan     0.0500    0.0000
   200        0.0006             nan     0.0500    0.0000

- Fold12: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold12: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0415             nan     0.0500    0.0021
     2        0.0377             nan     0.0500    0.0028
     3        0.0350             nan     0.0500    0.0018
     4        0.0320             nan     0.0500    0.0024
     5        0.0302             nan     0.0500    0.0012
     6        0.0284             nan     0.0500    0.0017
     7        0.0270             nan     0.0500    0.0012
     8        0.0261             nan     0.0500    0.0002
     9        0.0243             nan     0.0500    0.0008
    10        0.0232             nan     0.0500    0.0006
    20        0.0125             nan     0.0500    0.0006
    40        0.0043             nan     0.0500    0.0003
    60        0.0015             nan     0.0500    0.0000
    80        0.0007             nan     0.0500   -0.0000
   100        0.0003             nan     0.0500    0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0001             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold12: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold12: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0419             nan     0.0500    0.0015
     2        0.0392             nan     0.0500    0.0019
     3        0.0362             nan     0.0500    0.0021
     4        0.0338             nan     0.0500    0.0017
     5        0.0313             nan     0.0500    0.0019
     6        0.0289             nan     0.0500    0.0015
     7        0.0272             nan     0.0500    0.0016
     8        0.0255             nan     0.0500    0.0011
     9        0.0239             nan     0.0500    0.0014
    10        0.0224             nan     0.0500    0.0013
    20        0.0129             nan     0.0500    0.0010
    40        0.0048             nan     0.0500    0.0003
    60        0.0023             nan     0.0500   -0.0000
    80        0.0012             nan     0.0500   -0.0000
   100        0.0007             nan     0.0500    0.0000
   120        0.0005             nan     0.0500   -0.0000
   140        0.0003             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500    0.0000
   180        0.0001             nan     0.0500    0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold12: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold12: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0414             nan     0.0500    0.0027
     2        0.0389             nan     0.0500    0.0025
     3        0.0375             nan     0.0500    0.0000
     4        0.0373             nan     0.0500   -0.0017
     5        0.0347             nan     0.0500    0.0019
     6        0.0328             nan     0.0500    0.0004
     7        0.0308             nan     0.0500    0.0021
     8        0.0290             nan     0.0500    0.0011
     9        0.0276             nan     0.0500    0.0009
    10        0.0262             nan     0.0500    0.0009
    20        0.0179             nan     0.0500    0.0000
    40        0.0083             nan     0.0500    0.0001
    60        0.0043             nan     0.0500    0.0000
    80        0.0025             nan     0.0500    0.0000
   100        0.0018             nan     0.0500   -0.0000
   120        0.0012             nan     0.0500   -0.0000
   140        0.0008             nan     0.0500    0.0000
   160        0.0006             nan     0.0500   -0.0000
   180        0.0004             nan     0.0500   -0.0000
   200        0.0003             nan     0.0500   -0.0000

- Fold12: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold12: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0398             nan     0.0500    0.0036
     2        0.0372             nan     0.0500    0.0013
     3        0.0340             nan     0.0500    0.0030
     4        0.0323             nan     0.0500    0.0012
     5        0.0298             nan     0.0500    0.0012
     6        0.0281             nan     0.0500    0.0009
     7        0.0260             nan     0.0500    0.0023
     8        0.0240             nan     0.0500    0.0021
     9        0.0218             nan     0.0500    0.0019
    10        0.0197             nan     0.0500    0.0013
    20        0.0107             nan     0.0500    0.0004
    40        0.0040             nan     0.0500   -0.0000
    60        0.0013             nan     0.0500    0.0000
    80        0.0005             nan     0.0500   -0.0000
   100        0.0002             nan     0.0500   -0.0000
   120        0.0001             nan     0.0500    0.0000
   140        0.0001             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500    0.0000

- Fold12: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold12: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0405             nan     0.0500    0.0036
     2        0.0388             nan     0.0500    0.0012
     3        0.0358             nan     0.0500    0.0021
     4        0.0341             nan     0.0500    0.0017
     5        0.0308             nan     0.0500    0.0024
     6        0.0290             nan     0.0500    0.0015
     7        0.0274             nan     0.0500    0.0015
     8        0.0257             nan     0.0500    0.0002
     9        0.0244             nan     0.0500    0.0010
    10        0.0232             nan     0.0500    0.0008
    20        0.0132             nan     0.0500    0.0009
    40        0.0046             nan     0.0500    0.0002
    60        0.0027             nan     0.0500   -0.0000
    80        0.0014             nan     0.0500   -0.0000
   100        0.0009             nan     0.0500   -0.0000
   120        0.0005             nan     0.0500   -0.0000
   140        0.0004             nan     0.0500    0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0002             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold12: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold12: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0411             nan     0.0500    0.0027
     2        0.0384             nan     0.0500    0.0024
     3        0.0366             nan     0.0500    0.0014
     4        0.0349             nan     0.0500    0.0010
     5        0.0322             nan     0.0500    0.0021
     6        0.0310             nan     0.0500    0.0010
     7        0.0294             nan     0.0500    0.0018
     8        0.0273             nan     0.0500    0.0017
     9        0.0263             nan     0.0500    0.0010
    10        0.0249             nan     0.0500    0.0007
    20        0.0162             nan     0.0500    0.0003
    40        0.0080             nan     0.0500   -0.0000
    60        0.0047             nan     0.0500    0.0000
    80        0.0035             nan     0.0500   -0.0000
   100        0.0022             nan     0.0500   -0.0001
   120        0.0016             nan     0.0500   -0.0001
   140        0.0010             nan     0.0500    0.0000
   160        0.0008             nan     0.0500    0.0000
   180        0.0006             nan     0.0500   -0.0000
   200        0.0004             nan     0.0500    0.0000

- Fold12: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold12: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0379             nan     0.1000    0.0058
     2        0.0328             nan     0.1000    0.0049
     3        0.0307             nan     0.1000   -0.0007
     4        0.0283             nan     0.1000    0.0020
     5        0.0265             nan     0.1000    0.0004
     6        0.0242             nan     0.1000    0.0013
     7        0.0218             nan     0.1000    0.0028
     8        0.0202             nan     0.1000    0.0012
     9        0.0179             nan     0.1000    0.0014
    10        0.0163             nan     0.1000    0.0007
    20        0.0075             nan     0.1000    0.0006
    40        0.0021             nan     0.1000    0.0000
    60        0.0007             nan     0.1000   -0.0000
    80        0.0003             nan     0.1000    0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000    0.0000
   180        0.0000             nan     0.1000    0.0000
   200        0.0000             nan     0.1000    0.0000

- Fold12: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold12: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0373             nan     0.1000    0.0057
     2        0.0332             nan     0.1000    0.0043
     3        0.0314             nan     0.1000    0.0002
     4        0.0278             nan     0.1000    0.0020
     5        0.0256             nan     0.1000    0.0008
     6        0.0228             nan     0.1000    0.0014
     7        0.0207             nan     0.1000    0.0010
     8        0.0183             nan     0.1000    0.0024
     9        0.0165             nan     0.1000    0.0007
    10        0.0145             nan     0.1000    0.0017
    20        0.0061             nan     0.1000    0.0003
    40        0.0019             nan     0.1000    0.0000
    60        0.0007             nan     0.1000   -0.0000
    80        0.0003             nan     0.1000   -0.0000
   100        0.0002             nan     0.1000   -0.0000
   120        0.0001             nan     0.1000    0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000    0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold12: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold12: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0390             nan     0.1000    0.0039
     2        0.0346             nan     0.1000    0.0041
     3        0.0302             nan     0.1000    0.0039
     4        0.0275             nan     0.1000    0.0008
     5        0.0245             nan     0.1000    0.0016
     6        0.0225             nan     0.1000    0.0013
     7        0.0204             nan     0.1000   -0.0004
     8        0.0181             nan     0.1000    0.0017
     9        0.0168             nan     0.1000    0.0017
    10        0.0150             nan     0.1000    0.0014
    20        0.0077             nan     0.1000    0.0002
    40        0.0031             nan     0.1000   -0.0002
    60        0.0016             nan     0.1000    0.0000
    80        0.0009             nan     0.1000   -0.0000
   100        0.0004             nan     0.1000    0.0000
   120        0.0003             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000    0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold12: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold12: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0396             nan     0.1000    0.0004
     2        0.0335             nan     0.1000    0.0050
     3        0.0283             nan     0.1000    0.0048
     4        0.0260             nan     0.1000   -0.0000
     5        0.0217             nan     0.1000    0.0037
     6        0.0196             nan     0.1000    0.0009
     7        0.0176             nan     0.1000    0.0021
     8        0.0151             nan     0.1000    0.0016
     9        0.0140             nan     0.1000    0.0000
    10        0.0123             nan     0.1000    0.0008
    20        0.0035             nan     0.1000   -0.0001
    40        0.0006             nan     0.1000    0.0000
    60        0.0002             nan     0.1000    0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000    0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000    0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold12: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold12: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0382             nan     0.1000    0.0031
     2        0.0350             nan     0.1000    0.0014
     3        0.0316             nan     0.1000    0.0003
     4        0.0284             nan     0.1000    0.0009
     5        0.0238             nan     0.1000    0.0039
     6        0.0204             nan     0.1000    0.0034
     7        0.0179             nan     0.1000    0.0025
     8        0.0157             nan     0.1000    0.0019
     9        0.0146             nan     0.1000    0.0004
    10        0.0130             nan     0.1000    0.0014
    20        0.0044             nan     0.1000    0.0005
    40        0.0011             nan     0.1000    0.0000
    60        0.0004             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold12: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold12: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0380             nan     0.1000    0.0061
     2        0.0336             nan     0.1000    0.0034
     3        0.0292             nan     0.1000    0.0032
     4        0.0277             nan     0.1000    0.0011
     5        0.0261             nan     0.1000    0.0013
     6        0.0234             nan     0.1000    0.0027
     7        0.0209             nan     0.1000    0.0025
     8        0.0189             nan     0.1000    0.0020
     9        0.0176             nan     0.1000    0.0009
    10        0.0167             nan     0.1000   -0.0008
    20        0.0085             nan     0.1000    0.0000
    40        0.0037             nan     0.1000   -0.0001
    60        0.0018             nan     0.1000   -0.0000
    80        0.0009             nan     0.1000   -0.0001
   100        0.0005             nan     0.1000   -0.0000
   120        0.0003             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000    0.0000
   160        0.0001             nan     0.1000    0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold12: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold12: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0381             nan     0.1000    0.0028
     2        0.0333             nan     0.1000    0.0046
     3        0.0289             nan     0.1000    0.0035
     4        0.0245             nan     0.1000    0.0048
     5        0.0215             nan     0.1000    0.0020
     6        0.0193             nan     0.1000    0.0023
     7        0.0174             nan     0.1000    0.0017
     8        0.0156             nan     0.1000    0.0010
     9        0.0130             nan     0.1000    0.0011
    10        0.0108             nan     0.1000    0.0013
    20        0.0038             nan     0.1000    0.0003
    40        0.0008             nan     0.1000    0.0000
    60        0.0001             nan     0.1000   -0.0000
    80        0.0000             nan     0.1000    0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000    0.0000
   160        0.0000             nan     0.1000    0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000    0.0000

- Fold12: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold12: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0376             nan     0.1000    0.0062
     2        0.0338             nan     0.1000    0.0038
     3        0.0295             nan     0.1000    0.0032
     4        0.0260             nan     0.1000    0.0027
     5        0.0234             nan     0.1000    0.0012
     6        0.0210             nan     0.1000    0.0027
     7        0.0179             nan     0.1000    0.0026
     8        0.0148             nan     0.1000    0.0013
     9        0.0138             nan     0.1000   -0.0002
    10        0.0133             nan     0.1000   -0.0014
    20        0.0040             nan     0.1000    0.0003
    40        0.0014             nan     0.1000    0.0001
    60        0.0006             nan     0.1000    0.0000
    80        0.0003             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0001             nan     0.1000    0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000    0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold12: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold12: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0378             nan     0.1000    0.0036
     2        0.0327             nan     0.1000    0.0044
     3        0.0279             nan     0.1000    0.0036
     4        0.0255             nan     0.1000    0.0001
     5        0.0236             nan     0.1000    0.0015
     6        0.0216             nan     0.1000   -0.0005
     7        0.0203             nan     0.1000   -0.0011
     8        0.0180             nan     0.1000    0.0017
     9        0.0157             nan     0.1000    0.0008
    10        0.0143             nan     0.1000    0.0011
    20        0.0081             nan     0.1000    0.0001
    40        0.0029             nan     0.1000    0.0001
    60        0.0014             nan     0.1000   -0.0000
    80        0.0007             nan     0.1000    0.0000
   100        0.0004             nan     0.1000   -0.0000
   120        0.0002             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000    0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold12: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold13: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0441             nan     0.0100    0.0001
     2        0.0435             nan     0.0100    0.0006
     3        0.0431             nan     0.0100    0.0003
     4        0.0426             nan     0.0100    0.0006
     5        0.0419             nan     0.0100    0.0005
     6        0.0412             nan     0.0100    0.0005
     7        0.0408             nan     0.0100    0.0003
     8        0.0404             nan     0.0100    0.0004
     9        0.0398             nan     0.0100    0.0006
    10        0.0391             nan     0.0100    0.0006
    20        0.0347             nan     0.0100    0.0001
    40        0.0273             nan     0.0100    0.0002
    60        0.0229             nan     0.0100    0.0002
    80        0.0188             nan     0.0100    0.0000
   100        0.0150             nan     0.0100    0.0001
   120        0.0126             nan     0.0100    0.0000
   140        0.0105             nan     0.0100    0.0000
   160        0.0086             nan     0.0100    0.0000
   180        0.0073             nan     0.0100    0.0000
   200        0.0063             nan     0.0100    0.0000

- Fold13: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold13: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0437             nan     0.0100    0.0006
     2        0.0432             nan     0.0100    0.0003
     3        0.0426             nan     0.0100    0.0003
     4        0.0421             nan     0.0100    0.0002
     5        0.0415             nan     0.0100    0.0005
     6        0.0410             nan     0.0100    0.0003
     7        0.0406             nan     0.0100    0.0005
     8        0.0401             nan     0.0100    0.0005
     9        0.0397             nan     0.0100   -0.0000
    10        0.0392             nan     0.0100    0.0005
    20        0.0350             nan     0.0100    0.0002
    40        0.0275             nan     0.0100    0.0002
    60        0.0229             nan     0.0100    0.0002
    80        0.0185             nan     0.0100    0.0002
   100        0.0156             nan     0.0100   -0.0000
   120        0.0128             nan     0.0100    0.0001
   140        0.0106             nan     0.0100    0.0001
   160        0.0091             nan     0.0100    0.0001
   180        0.0076             nan     0.0100    0.0001
   200        0.0065             nan     0.0100    0.0000

- Fold13: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold13: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0442             nan     0.0100   -0.0001
     2        0.0437             nan     0.0100    0.0002
     3        0.0432             nan     0.0100    0.0002
     4        0.0427             nan     0.0100    0.0006
     5        0.0421             nan     0.0100    0.0006
     6        0.0416             nan     0.0100    0.0003
     7        0.0412             nan     0.0100    0.0003
     8        0.0405             nan     0.0100    0.0005
     9        0.0398             nan     0.0100    0.0005
    10        0.0394             nan     0.0100    0.0003
    20        0.0352             nan     0.0100    0.0005
    40        0.0280             nan     0.0100    0.0002
    60        0.0226             nan     0.0100    0.0003
    80        0.0189             nan     0.0100    0.0001
   100        0.0156             nan     0.0100    0.0000
   120        0.0134             nan     0.0100    0.0000
   140        0.0117             nan     0.0100    0.0001
   160        0.0102             nan     0.0100    0.0001
   180        0.0089             nan     0.0100    0.0001
   200        0.0079             nan     0.0100    0.0000

- Fold13: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold13: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0440             nan     0.0100    0.0000
     2        0.0433             nan     0.0100    0.0007
     3        0.0427             nan     0.0100    0.0005
     4        0.0420             nan     0.0100    0.0006
     5        0.0414             nan     0.0100    0.0006
     6        0.0407             nan     0.0100    0.0004
     7        0.0401             nan     0.0100    0.0006
     8        0.0395             nan     0.0100    0.0003
     9        0.0389             nan     0.0100    0.0007
    10        0.0381             nan     0.0100    0.0005
    20        0.0334             nan     0.0100   -0.0002
    40        0.0254             nan     0.0100   -0.0000
    60        0.0191             nan     0.0100    0.0002
    80        0.0147             nan     0.0100    0.0000
   100        0.0114             nan     0.0100    0.0002
   120        0.0089             nan     0.0100   -0.0000
   140        0.0072             nan     0.0100    0.0000
   160        0.0060             nan     0.0100    0.0000
   180        0.0049             nan     0.0100    0.0000
   200        0.0040             nan     0.0100   -0.0000

- Fold13: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold13: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0440             nan     0.0100    0.0004
     2        0.0432             nan     0.0100    0.0007
     3        0.0428             nan     0.0100    0.0006
     4        0.0421             nan     0.0100    0.0006
     5        0.0416             nan     0.0100    0.0001
     6        0.0410             nan     0.0100    0.0004
     7        0.0403             nan     0.0100    0.0004
     8        0.0400             nan     0.0100    0.0004
     9        0.0392             nan     0.0100    0.0004
    10        0.0385             nan     0.0100    0.0005
    20        0.0337             nan     0.0100    0.0003
    40        0.0262             nan     0.0100    0.0001
    60        0.0206             nan     0.0100    0.0000
    80        0.0168             nan     0.0100   -0.0000
   100        0.0133             nan     0.0100    0.0002
   120        0.0105             nan     0.0100    0.0000
   140        0.0086             nan     0.0100    0.0001
   160        0.0070             nan     0.0100   -0.0000
   180        0.0058             nan     0.0100   -0.0000
   200        0.0047             nan     0.0100    0.0000

- Fold13: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold13: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0440             nan     0.0100    0.0005
     2        0.0434             nan     0.0100    0.0006
     3        0.0430             nan     0.0100    0.0001
     4        0.0427             nan     0.0100    0.0002
     5        0.0423             nan     0.0100   -0.0000
     6        0.0418             nan     0.0100    0.0006
     7        0.0411             nan     0.0100    0.0006
     8        0.0407             nan     0.0100    0.0003
     9        0.0402             nan     0.0100    0.0001
    10        0.0398             nan     0.0100    0.0004
    20        0.0356             nan     0.0100    0.0004
    40        0.0281             nan     0.0100    0.0003
    60        0.0233             nan     0.0100    0.0001
    80        0.0190             nan     0.0100    0.0002
   100        0.0161             nan     0.0100    0.0001
   120        0.0138             nan     0.0100    0.0000
   140        0.0120             nan     0.0100    0.0000
   160        0.0105             nan     0.0100    0.0000
   180        0.0093             nan     0.0100    0.0001
   200        0.0084             nan     0.0100    0.0000

- Fold13: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold13: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0436             nan     0.0100    0.0008
     2        0.0431             nan     0.0100    0.0004
     3        0.0423             nan     0.0100    0.0005
     4        0.0418             nan     0.0100    0.0005
     5        0.0413             nan     0.0100    0.0004
     6        0.0406             nan     0.0100    0.0006
     7        0.0397             nan     0.0100    0.0011
     8        0.0391             nan     0.0100    0.0004
     9        0.0386             nan     0.0100    0.0002
    10        0.0382             nan     0.0100    0.0005
    20        0.0322             nan     0.0100    0.0005
    40        0.0240             nan     0.0100    0.0001
    60        0.0182             nan     0.0100    0.0002
    80        0.0137             nan     0.0100    0.0002
   100        0.0107             nan     0.0100    0.0000
   120        0.0084             nan     0.0100    0.0001
   140        0.0066             nan     0.0100    0.0000
   160        0.0052             nan     0.0100    0.0000
   180        0.0041             nan     0.0100    0.0000
   200        0.0033             nan     0.0100    0.0000

- Fold13: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold13: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0439             nan     0.0100    0.0006
     2        0.0434             nan     0.0100    0.0005
     3        0.0428             nan     0.0100    0.0007
     4        0.0423             nan     0.0100    0.0004
     5        0.0419             nan     0.0100    0.0002
     6        0.0414             nan     0.0100    0.0005
     7        0.0407             nan     0.0100    0.0005
     8        0.0401             nan     0.0100    0.0004
     9        0.0395             nan     0.0100    0.0005
    10        0.0388             nan     0.0100    0.0006
    20        0.0339             nan     0.0100    0.0005
    40        0.0264             nan     0.0100    0.0002
    60        0.0198             nan     0.0100    0.0001
    80        0.0154             nan     0.0100    0.0001
   100        0.0119             nan     0.0100    0.0001
   120        0.0095             nan     0.0100    0.0001
   140        0.0077             nan     0.0100    0.0001
   160        0.0062             nan     0.0100    0.0001
   180        0.0052             nan     0.0100    0.0000
   200        0.0043             nan     0.0100    0.0000

- Fold13: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold13: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0440             nan     0.0100    0.0005
     2        0.0433             nan     0.0100    0.0007
     3        0.0427             nan     0.0100    0.0006
     4        0.0420             nan     0.0100    0.0006
     5        0.0414             nan     0.0100    0.0006
     6        0.0409             nan     0.0100    0.0005
     7        0.0407             nan     0.0100   -0.0000
     8        0.0402             nan     0.0100    0.0005
     9        0.0397             nan     0.0100    0.0002
    10        0.0394             nan     0.0100    0.0001
    20        0.0356             nan     0.0100    0.0000
    40        0.0287             nan     0.0100    0.0001
    60        0.0233             nan     0.0100    0.0003
    80        0.0194             nan     0.0100    0.0001
   100        0.0162             nan     0.0100    0.0001
   120        0.0140             nan     0.0100    0.0001
   140        0.0121             nan     0.0100    0.0000
   160        0.0104             nan     0.0100    0.0001
   180        0.0091             nan     0.0100    0.0001
   200        0.0079             nan     0.0100    0.0000

- Fold13: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold13: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0430             nan     0.0500    0.0005
     2        0.0400             nan     0.0500    0.0026
     3        0.0382             nan     0.0500    0.0011
     4        0.0357             nan     0.0500    0.0026
     5        0.0334             nan     0.0500    0.0015
     6        0.0313             nan     0.0500    0.0019
     7        0.0299             nan     0.0500    0.0013
     8        0.0277             nan     0.0500    0.0021
     9        0.0263             nan     0.0500    0.0015
    10        0.0251             nan     0.0500    0.0014
    20        0.0144             nan     0.0500    0.0008
    40        0.0056             nan     0.0500    0.0001
    60        0.0026             nan     0.0500    0.0001
    80        0.0014             nan     0.0500   -0.0000
   100        0.0008             nan     0.0500   -0.0000
   120        0.0005             nan     0.0500   -0.0000
   140        0.0003             nan     0.0500    0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500    0.0000

- Fold13: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold13: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0420             nan     0.0500    0.0021
     2        0.0398             nan     0.0500    0.0023
     3        0.0374             nan     0.0500    0.0021
     4        0.0352             nan     0.0500    0.0022
     5        0.0340             nan     0.0500    0.0001
     6        0.0322             nan     0.0500    0.0011
     7        0.0304             nan     0.0500    0.0003
     8        0.0295             nan     0.0500   -0.0002
     9        0.0277             nan     0.0500    0.0003
    10        0.0260             nan     0.0500    0.0011
    20        0.0163             nan     0.0500    0.0005
    40        0.0067             nan     0.0500    0.0001
    60        0.0029             nan     0.0500   -0.0000
    80        0.0017             nan     0.0500   -0.0001
   100        0.0011             nan     0.0500   -0.0000
   120        0.0007             nan     0.0500   -0.0000
   140        0.0005             nan     0.0500   -0.0000
   160        0.0003             nan     0.0500    0.0000
   180        0.0002             nan     0.0500    0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold13: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold13: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0415             nan     0.0500    0.0030
     2        0.0399             nan     0.0500    0.0018
     3        0.0370             nan     0.0500    0.0024
     4        0.0346             nan     0.0500    0.0021
     5        0.0331             nan     0.0500    0.0012
     6        0.0316             nan     0.0500    0.0011
     7        0.0302             nan     0.0500    0.0014
     8        0.0282             nan     0.0500    0.0019
     9        0.0272             nan     0.0500    0.0008
    10        0.0258             nan     0.0500    0.0015
    20        0.0153             nan     0.0500    0.0004
    40        0.0083             nan     0.0500    0.0000
    60        0.0051             nan     0.0500    0.0001
    80        0.0037             nan     0.0500   -0.0000
   100        0.0026             nan     0.0500   -0.0000
   120        0.0018             nan     0.0500   -0.0000
   140        0.0013             nan     0.0500   -0.0001
   160        0.0009             nan     0.0500    0.0000
   180        0.0007             nan     0.0500    0.0000
   200        0.0005             nan     0.0500   -0.0000

- Fold13: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold13: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0406             nan     0.0500    0.0038
     2        0.0376             nan     0.0500    0.0027
     3        0.0351             nan     0.0500    0.0019
     4        0.0318             nan     0.0500    0.0027
     5        0.0290             nan     0.0500    0.0023
     6        0.0269             nan     0.0500    0.0006
     7        0.0258             nan     0.0500    0.0007
     8        0.0238             nan     0.0500    0.0018
     9        0.0218             nan     0.0500    0.0013
    10        0.0204             nan     0.0500    0.0018
    20        0.0108             nan     0.0500    0.0002
    40        0.0041             nan     0.0500    0.0000
    60        0.0014             nan     0.0500    0.0001
    80        0.0005             nan     0.0500    0.0000
   100        0.0002             nan     0.0500   -0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0001             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500    0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold13: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold13: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0409             nan     0.0500    0.0023
     2        0.0392             nan     0.0500    0.0005
     3        0.0373             nan     0.0500    0.0015
     4        0.0339             nan     0.0500    0.0033
     5        0.0309             nan     0.0500    0.0017
     6        0.0285             nan     0.0500    0.0015
     7        0.0266             nan     0.0500    0.0013
     8        0.0245             nan     0.0500    0.0018
     9        0.0230             nan     0.0500    0.0015
    10        0.0221             nan     0.0500   -0.0000
    20        0.0122             nan     0.0500    0.0006
    40        0.0050             nan     0.0500    0.0001
    60        0.0020             nan     0.0500   -0.0001
    80        0.0010             nan     0.0500    0.0000
   100        0.0006             nan     0.0500   -0.0000
   120        0.0003             nan     0.0500   -0.0000
   140        0.0002             nan     0.0500   -0.0000
   160        0.0001             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500    0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold13: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold13: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0415             nan     0.0500    0.0030
     2        0.0385             nan     0.0500    0.0023
     3        0.0360             nan     0.0500    0.0021
     4        0.0343             nan     0.0500    0.0015
     5        0.0320             nan     0.0500    0.0019
     6        0.0298             nan     0.0500    0.0021
     7        0.0276             nan     0.0500    0.0012
     8        0.0257             nan     0.0500    0.0016
     9        0.0249             nan     0.0500    0.0009
    10        0.0237             nan     0.0500    0.0013
    20        0.0158             nan     0.0500   -0.0001
    40        0.0090             nan     0.0500    0.0002
    60        0.0058             nan     0.0500    0.0001
    80        0.0043             nan     0.0500    0.0000
   100        0.0029             nan     0.0500   -0.0001
   120        0.0020             nan     0.0500    0.0000
   140        0.0015             nan     0.0500    0.0000
   160        0.0011             nan     0.0500   -0.0001
   180        0.0008             nan     0.0500    0.0000
   200        0.0007             nan     0.0500   -0.0000

- Fold13: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold13: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0405             nan     0.0500    0.0029
     2        0.0379             nan     0.0500    0.0024
     3        0.0353             nan     0.0500    0.0013
     4        0.0326             nan     0.0500    0.0023
     5        0.0301             nan     0.0500    0.0023
     6        0.0277             nan     0.0500    0.0018
     7        0.0259             nan     0.0500    0.0017
     8        0.0240             nan     0.0500    0.0003
     9        0.0236             nan     0.0500   -0.0011
    10        0.0220             nan     0.0500    0.0021
    20        0.0113             nan     0.0500    0.0001
    40        0.0032             nan     0.0500    0.0001
    60        0.0011             nan     0.0500    0.0000
    80        0.0004             nan     0.0500    0.0000
   100        0.0002             nan     0.0500    0.0000
   120        0.0001             nan     0.0500    0.0000
   140        0.0000             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold13: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold13: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0410             nan     0.0500    0.0025
     2        0.0377             nan     0.0500    0.0021
     3        0.0354             nan     0.0500    0.0020
     4        0.0333             nan     0.0500    0.0020
     5        0.0313             nan     0.0500    0.0021
     6        0.0292             nan     0.0500    0.0015
     7        0.0273             nan     0.0500    0.0015
     8        0.0259             nan     0.0500    0.0008
     9        0.0252             nan     0.0500    0.0006
    10        0.0230             nan     0.0500    0.0007
    20        0.0129             nan     0.0500   -0.0003
    40        0.0046             nan     0.0500    0.0002
    60        0.0017             nan     0.0500    0.0000
    80        0.0008             nan     0.0500   -0.0000
   100        0.0004             nan     0.0500    0.0000
   120        0.0002             nan     0.0500    0.0000
   140        0.0001             nan     0.0500    0.0000
   160        0.0001             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold13: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold13: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0408             nan     0.0500    0.0023
     2        0.0397             nan     0.0500   -0.0000
     3        0.0364             nan     0.0500    0.0021
     4        0.0349             nan     0.0500   -0.0007
     5        0.0331             nan     0.0500    0.0017
     6        0.0317             nan     0.0500    0.0012
     7        0.0302             nan     0.0500    0.0012
     8        0.0281             nan     0.0500    0.0021
     9        0.0269             nan     0.0500    0.0013
    10        0.0250             nan     0.0500    0.0009
    20        0.0158             nan     0.0500    0.0006
    40        0.0076             nan     0.0500    0.0001
    60        0.0050             nan     0.0500   -0.0002
    80        0.0033             nan     0.0500   -0.0001
   100        0.0025             nan     0.0500   -0.0000
   120        0.0018             nan     0.0500    0.0000
   140        0.0012             nan     0.0500   -0.0000
   160        0.0009             nan     0.0500    0.0000
   180        0.0007             nan     0.0500    0.0000
   200        0.0005             nan     0.0500    0.0000

- Fold13: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold13: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0390             nan     0.1000    0.0057
     2        0.0360             nan     0.1000    0.0005
     3        0.0336             nan     0.1000    0.0007
     4        0.0300             nan     0.1000    0.0037
     5        0.0266             nan     0.1000    0.0035
     6        0.0236             nan     0.1000    0.0002
     7        0.0217             nan     0.1000   -0.0000
     8        0.0192             nan     0.1000    0.0026
     9        0.0172             nan     0.1000    0.0016
    10        0.0156             nan     0.1000    0.0017
    20        0.0057             nan     0.1000    0.0002
    40        0.0015             nan     0.1000   -0.0001
    60        0.0006             nan     0.1000   -0.0000
    80        0.0002             nan     0.1000    0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000    0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold13: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold13: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0394             nan     0.1000    0.0060
     2        0.0353             nan     0.1000    0.0045
     3        0.0317             nan     0.1000    0.0026
     4        0.0278             nan     0.1000    0.0019
     5        0.0241             nan     0.1000    0.0025
     6        0.0211             nan     0.1000    0.0024
     7        0.0187             nan     0.1000    0.0003
     8        0.0166             nan     0.1000    0.0014
     9        0.0143             nan     0.1000    0.0006
    10        0.0124             nan     0.1000    0.0017
    20        0.0053             nan     0.1000    0.0005
    40        0.0020             nan     0.1000    0.0001
    60        0.0008             nan     0.1000   -0.0001
    80        0.0003             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000    0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000    0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold13: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold13: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0412             nan     0.1000    0.0022
     2        0.0367             nan     0.1000    0.0051
     3        0.0317             nan     0.1000    0.0047
     4        0.0296             nan     0.1000    0.0010
     5        0.0279             nan     0.1000    0.0019
     6        0.0247             nan     0.1000    0.0014
     7        0.0227             nan     0.1000    0.0012
     8        0.0216             nan     0.1000    0.0007
     9        0.0191             nan     0.1000    0.0017
    10        0.0185             nan     0.1000   -0.0004
    20        0.0094             nan     0.1000    0.0001
    40        0.0051             nan     0.1000   -0.0002
    60        0.0030             nan     0.1000   -0.0001
    80        0.0017             nan     0.1000   -0.0000
   100        0.0009             nan     0.1000   -0.0000
   120        0.0005             nan     0.1000   -0.0000
   140        0.0003             nan     0.1000   -0.0000
   160        0.0002             nan     0.1000   -0.0000
   180        0.0002             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000    0.0000

- Fold13: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold13: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0378             nan     0.1000    0.0064
     2        0.0327             nan     0.1000    0.0046
     3        0.0284             nan     0.1000    0.0004
     4        0.0252             nan     0.1000    0.0027
     5        0.0220             nan     0.1000    0.0017
     6        0.0183             nan     0.1000    0.0029
     7        0.0160             nan     0.1000    0.0020
     8        0.0150             nan     0.1000    0.0001
     9        0.0133             nan     0.1000    0.0014
    10        0.0122             nan     0.1000    0.0005
    20        0.0039             nan     0.1000    0.0002
    40        0.0008             nan     0.1000   -0.0000
    60        0.0002             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000    0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold13: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold13: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0383             nan     0.1000    0.0064
     2        0.0340             nan     0.1000    0.0046
     3        0.0301             nan     0.1000    0.0029
     4        0.0262             nan     0.1000    0.0046
     5        0.0235             nan     0.1000   -0.0002
     6        0.0205             nan     0.1000    0.0014
     7        0.0185             nan     0.1000    0.0014
     8        0.0156             nan     0.1000    0.0022
     9        0.0135             nan     0.1000    0.0010
    10        0.0120             nan     0.1000    0.0009
    20        0.0036             nan     0.1000   -0.0001
    40        0.0010             nan     0.1000   -0.0000
    60        0.0003             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000    0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold13: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold13: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0385             nan     0.1000    0.0033
     2        0.0345             nan     0.1000    0.0022
     3        0.0330             nan     0.1000   -0.0004
     4        0.0287             nan     0.1000    0.0038
     5        0.0256             nan     0.1000    0.0019
     6        0.0226             nan     0.1000    0.0029
     7        0.0195             nan     0.1000    0.0020
     8        0.0179             nan     0.1000   -0.0011
     9        0.0165             nan     0.1000    0.0010
    10        0.0151             nan     0.1000    0.0017
    20        0.0086             nan     0.1000    0.0006
    40        0.0030             nan     0.1000    0.0001
    60        0.0015             nan     0.1000   -0.0000
    80        0.0007             nan     0.1000   -0.0000
   100        0.0004             nan     0.1000   -0.0000
   120        0.0002             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold13: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold13: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0371             nan     0.1000    0.0061
     2        0.0324             nan     0.1000    0.0047
     3        0.0287             nan     0.1000    0.0026
     4        0.0247             nan     0.1000    0.0022
     5        0.0219             nan     0.1000    0.0008
     6        0.0187             nan     0.1000    0.0026
     7        0.0165             nan     0.1000    0.0000
     8        0.0146             nan     0.1000    0.0017
     9        0.0120             nan     0.1000    0.0019
    10        0.0100             nan     0.1000    0.0007
    20        0.0036             nan     0.1000    0.0001
    40        0.0008             nan     0.1000   -0.0000
    60        0.0002             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000    0.0000
   120        0.0000             nan     0.1000    0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold13: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold13: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0374             nan     0.1000    0.0060
     2        0.0325             nan     0.1000    0.0045
     3        0.0271             nan     0.1000    0.0039
     4        0.0223             nan     0.1000    0.0041
     5        0.0188             nan     0.1000    0.0030
     6        0.0170             nan     0.1000    0.0015
     7        0.0152             nan     0.1000    0.0017
     8        0.0145             nan     0.1000   -0.0008
     9        0.0133             nan     0.1000    0.0007
    10        0.0125             nan     0.1000    0.0008
    20        0.0039             nan     0.1000    0.0004
    40        0.0013             nan     0.1000    0.0000
    60        0.0004             nan     0.1000    0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000    0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold13: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold13: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0386             nan     0.1000    0.0060
     2        0.0355             nan     0.1000    0.0025
     3        0.0308             nan     0.1000    0.0043
     4        0.0266             nan     0.1000    0.0032
     5        0.0240             nan     0.1000    0.0030
     6        0.0233             nan     0.1000    0.0004
     7        0.0225             nan     0.1000   -0.0000
     8        0.0206             nan     0.1000    0.0020
     9        0.0190             nan     0.1000    0.0001
    10        0.0170             nan     0.1000    0.0018
    20        0.0083             nan     0.1000    0.0000
    40        0.0039             nan     0.1000   -0.0002
    60        0.0020             nan     0.1000    0.0000
    80        0.0012             nan     0.1000    0.0001
   100        0.0007             nan     0.1000   -0.0000
   120        0.0005             nan     0.1000   -0.0000
   140        0.0004             nan     0.1000   -0.0000
   160        0.0002             nan     0.1000   -0.0000
   180        0.0002             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold13: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold14: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0430             nan     0.0100    0.0006
     2        0.0428             nan     0.0100   -0.0001
     3        0.0426             nan     0.0100    0.0000
     4        0.0421             nan     0.0100    0.0005
     5        0.0416             nan     0.0100    0.0005
     6        0.0409             nan     0.0100    0.0005
     7        0.0404             nan     0.0100    0.0006
     8        0.0398             nan     0.0100    0.0005
     9        0.0393             nan     0.0100    0.0004
    10        0.0388             nan     0.0100    0.0001
    20        0.0348             nan     0.0100    0.0003
    40        0.0276             nan     0.0100    0.0003
    60        0.0223             nan     0.0100    0.0002
    80        0.0179             nan     0.0100    0.0000
   100        0.0149             nan     0.0100    0.0000
   120        0.0125             nan     0.0100   -0.0000
   140        0.0105             nan     0.0100    0.0001
   160        0.0088             nan     0.0100    0.0001
   180        0.0075             nan     0.0100    0.0001
   200        0.0064             nan     0.0100    0.0001

- Fold14: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold14: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0431             nan     0.0100    0.0005
     2        0.0426             nan     0.0100    0.0004
     3        0.0421             nan     0.0100    0.0002
     4        0.0416             nan     0.0100    0.0005
     5        0.0410             nan     0.0100    0.0006
     6        0.0403             nan     0.0100    0.0006
     7        0.0398             nan     0.0100    0.0003
     8        0.0393             nan     0.0100    0.0004
     9        0.0390             nan     0.0100    0.0003
    10        0.0387             nan     0.0100    0.0004
    20        0.0342             nan     0.0100    0.0003
    40        0.0271             nan     0.0100    0.0003
    60        0.0218             nan     0.0100    0.0003
    80        0.0176             nan     0.0100    0.0001
   100        0.0144             nan     0.0100    0.0001
   120        0.0118             nan     0.0100    0.0001
   140        0.0100             nan     0.0100    0.0000
   160        0.0084             nan     0.0100    0.0000
   180        0.0071             nan     0.0100    0.0000
   200        0.0062             nan     0.0100    0.0000

- Fold14: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold14: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0432             nan     0.0100    0.0004
     2        0.0427             nan     0.0100    0.0004
     3        0.0423             nan     0.0100    0.0005
     4        0.0416             nan     0.0100    0.0005
     5        0.0412             nan     0.0100    0.0002
     6        0.0407             nan     0.0100    0.0004
     7        0.0401             nan     0.0100    0.0005
     8        0.0397             nan     0.0100    0.0003
     9        0.0394             nan     0.0100    0.0001
    10        0.0389             nan     0.0100    0.0005
    20        0.0349             nan     0.0100    0.0002
    40        0.0281             nan     0.0100    0.0001
    60        0.0228             nan     0.0100    0.0001
    80        0.0187             nan     0.0100    0.0001
   100        0.0158             nan     0.0100    0.0001
   120        0.0135             nan     0.0100    0.0000
   140        0.0117             nan     0.0100    0.0000
   160        0.0100             nan     0.0100    0.0001
   180        0.0086             nan     0.0100   -0.0001
   200        0.0077             nan     0.0100    0.0000

- Fold14: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold14: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0430             nan     0.0100    0.0007
     2        0.0426             nan     0.0100    0.0003
     3        0.0419             nan     0.0100    0.0005
     4        0.0414             nan     0.0100    0.0004
     5        0.0408             nan     0.0100    0.0005
     6        0.0402             nan     0.0100    0.0002
     7        0.0396             nan     0.0100    0.0007
     8        0.0388             nan     0.0100    0.0011
     9        0.0383             nan     0.0100    0.0004
    10        0.0375             nan     0.0100    0.0007
    20        0.0328             nan     0.0100    0.0006
    40        0.0256             nan     0.0100    0.0003
    60        0.0201             nan     0.0100    0.0000
    80        0.0156             nan     0.0100    0.0002
   100        0.0126             nan     0.0100    0.0000
   120        0.0100             nan     0.0100    0.0001
   140        0.0078             nan     0.0100    0.0001
   160        0.0062             nan     0.0100    0.0001
   180        0.0049             nan     0.0100    0.0001
   200        0.0040             nan     0.0100    0.0000

- Fold14: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold14: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0430             nan     0.0100    0.0007
     2        0.0425             nan     0.0100    0.0006
     3        0.0419             nan     0.0100    0.0006
     4        0.0413             nan     0.0100    0.0005
     5        0.0406             nan     0.0100    0.0006
     6        0.0400             nan     0.0100    0.0005
     7        0.0394             nan     0.0100    0.0003
     8        0.0388             nan     0.0100    0.0002
     9        0.0382             nan     0.0100    0.0004
    10        0.0375             nan     0.0100    0.0005
    20        0.0325             nan     0.0100    0.0004
    40        0.0250             nan     0.0100   -0.0000
    60        0.0194             nan     0.0100    0.0002
    80        0.0151             nan     0.0100    0.0002
   100        0.0117             nan     0.0100    0.0001
   120        0.0095             nan     0.0100    0.0001
   140        0.0076             nan     0.0100    0.0001
   160        0.0062             nan     0.0100   -0.0001
   180        0.0050             nan     0.0100    0.0000
   200        0.0041             nan     0.0100   -0.0000

- Fold14: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold14: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0431             nan     0.0100    0.0005
     2        0.0428             nan     0.0100    0.0000
     3        0.0423             nan     0.0100    0.0003
     4        0.0419             nan     0.0100    0.0004
     5        0.0413             nan     0.0100    0.0006
     6        0.0407             nan     0.0100    0.0006
     7        0.0403             nan     0.0100    0.0005
     8        0.0398             nan     0.0100    0.0005
     9        0.0394             nan     0.0100    0.0003
    10        0.0392             nan     0.0100    0.0002
    20        0.0348             nan     0.0100    0.0003
    40        0.0283             nan     0.0100    0.0002
    60        0.0228             nan     0.0100    0.0002
    80        0.0187             nan     0.0100    0.0002
   100        0.0157             nan     0.0100   -0.0000
   120        0.0136             nan     0.0100    0.0000
   140        0.0117             nan     0.0100    0.0000
   160        0.0103             nan     0.0100    0.0001
   180        0.0091             nan     0.0100   -0.0000
   200        0.0080             nan     0.0100    0.0000

- Fold14: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold14: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0431             nan     0.0100    0.0002
     2        0.0423             nan     0.0100    0.0007
     3        0.0417             nan     0.0100    0.0005
     4        0.0409             nan     0.0100    0.0007
     5        0.0406             nan     0.0100   -0.0002
     6        0.0399             nan     0.0100    0.0006
     7        0.0393             nan     0.0100    0.0004
     8        0.0385             nan     0.0100    0.0005
     9        0.0378             nan     0.0100    0.0006
    10        0.0374             nan     0.0100    0.0004
    20        0.0319             nan     0.0100    0.0005
    40        0.0241             nan     0.0100    0.0000
    60        0.0184             nan     0.0100    0.0003
    80        0.0139             nan     0.0100    0.0001
   100        0.0105             nan     0.0100    0.0001
   120        0.0080             nan     0.0100    0.0000
   140        0.0062             nan     0.0100    0.0000
   160        0.0049             nan     0.0100    0.0000
   180        0.0038             nan     0.0100    0.0000
   200        0.0030             nan     0.0100    0.0000

- Fold14: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold14: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0429             nan     0.0100    0.0004
     2        0.0421             nan     0.0100    0.0007
     3        0.0412             nan     0.0100    0.0005
     4        0.0407             nan     0.0100    0.0006
     5        0.0400             nan     0.0100    0.0007
     6        0.0396             nan     0.0100    0.0002
     7        0.0388             nan     0.0100    0.0005
     8        0.0383             nan     0.0100    0.0005
     9        0.0377             nan     0.0100    0.0005
    10        0.0370             nan     0.0100    0.0006
    20        0.0324             nan     0.0100    0.0002
    40        0.0246             nan     0.0100    0.0003
    60        0.0190             nan     0.0100    0.0002
    80        0.0145             nan     0.0100    0.0002
   100        0.0113             nan     0.0100    0.0000
   120        0.0090             nan     0.0100   -0.0000
   140        0.0072             nan     0.0100    0.0000
   160        0.0059             nan     0.0100   -0.0000
   180        0.0048             nan     0.0100    0.0000
   200        0.0040             nan     0.0100   -0.0000

- Fold14: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold14: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0432             nan     0.0100    0.0005
     2        0.0428             nan     0.0100    0.0003
     3        0.0422             nan     0.0100    0.0006
     4        0.0418             nan     0.0100    0.0003
     5        0.0412             nan     0.0100    0.0006
     6        0.0409             nan     0.0100    0.0002
     7        0.0405             nan     0.0100    0.0005
     8        0.0402             nan     0.0100    0.0002
     9        0.0399             nan     0.0100    0.0002
    10        0.0397             nan     0.0100    0.0001
    20        0.0354             nan     0.0100    0.0004
    40        0.0286             nan     0.0100    0.0003
    60        0.0234             nan     0.0100    0.0001
    80        0.0194             nan     0.0100    0.0001
   100        0.0164             nan     0.0100    0.0001
   120        0.0141             nan     0.0100    0.0000
   140        0.0123             nan     0.0100    0.0000
   160        0.0106             nan     0.0100    0.0001
   180        0.0095             nan     0.0100    0.0000
   200        0.0084             nan     0.0100    0.0000

- Fold14: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold14: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0405             nan     0.0500    0.0022
     2        0.0384             nan     0.0500    0.0024
     3        0.0365             nan     0.0500    0.0018
     4        0.0344             nan     0.0500    0.0018
     5        0.0337             nan     0.0500   -0.0006
     6        0.0313             nan     0.0500    0.0022
     7        0.0300             nan     0.0500   -0.0003
     8        0.0279             nan     0.0500    0.0020
     9        0.0263             nan     0.0500    0.0015
    10        0.0250             nan     0.0500    0.0013
    20        0.0155             nan     0.0500    0.0004
    40        0.0065             nan     0.0500    0.0001
    60        0.0031             nan     0.0500    0.0000
    80        0.0018             nan     0.0500    0.0001
   100        0.0010             nan     0.0500    0.0000
   120        0.0006             nan     0.0500   -0.0000
   140        0.0004             nan     0.0500   -0.0000
   160        0.0003             nan     0.0500   -0.0000
   180        0.0002             nan     0.0500    0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold14: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold14: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0415             nan     0.0500    0.0014
     2        0.0387             nan     0.0500    0.0014
     3        0.0362             nan     0.0500    0.0027
     4        0.0346             nan     0.0500    0.0015
     5        0.0327             nan     0.0500    0.0002
     6        0.0304             nan     0.0500    0.0018
     7        0.0285             nan     0.0500    0.0021
     8        0.0269             nan     0.0500    0.0018
     9        0.0255             nan     0.0500    0.0003
    10        0.0238             nan     0.0500    0.0015
    20        0.0149             nan     0.0500    0.0008
    40        0.0065             nan     0.0500    0.0002
    60        0.0034             nan     0.0500   -0.0000
    80        0.0021             nan     0.0500   -0.0000
   100        0.0013             nan     0.0500    0.0000
   120        0.0009             nan     0.0500   -0.0000
   140        0.0005             nan     0.0500   -0.0000
   160        0.0003             nan     0.0500   -0.0000
   180        0.0002             nan     0.0500   -0.0000
   200        0.0002             nan     0.0500    0.0000

- Fold14: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold14: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0428             nan     0.0500   -0.0004
     2        0.0416             nan     0.0500    0.0006
     3        0.0387             nan     0.0500    0.0027
     4        0.0370             nan     0.0500    0.0020
     5        0.0346             nan     0.0500    0.0023
     6        0.0324             nan     0.0500    0.0019
     7        0.0303             nan     0.0500    0.0019
     8        0.0295             nan     0.0500    0.0006
     9        0.0286             nan     0.0500    0.0011
    10        0.0269             nan     0.0500    0.0015
    20        0.0170             nan     0.0500    0.0006
    40        0.0088             nan     0.0500   -0.0000
    60        0.0055             nan     0.0500   -0.0002
    80        0.0033             nan     0.0500    0.0001
   100        0.0021             nan     0.0500    0.0000
   120        0.0016             nan     0.0500    0.0000
   140        0.0013             nan     0.0500    0.0000
   160        0.0009             nan     0.0500    0.0000
   180        0.0006             nan     0.0500    0.0000
   200        0.0005             nan     0.0500   -0.0000

- Fold14: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold14: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0400             nan     0.0500    0.0023
     2        0.0363             nan     0.0500    0.0032
     3        0.0336             nan     0.0500    0.0013
     4        0.0313             nan     0.0500    0.0018
     5        0.0301             nan     0.0500    0.0009
     6        0.0276             nan     0.0500    0.0011
     7        0.0260             nan     0.0500    0.0014
     8        0.0236             nan     0.0500    0.0024
     9        0.0226             nan     0.0500    0.0008
    10        0.0213             nan     0.0500    0.0008
    20        0.0115             nan     0.0500    0.0002
    40        0.0046             nan     0.0500   -0.0001
    60        0.0018             nan     0.0500    0.0001
    80        0.0009             nan     0.0500    0.0000
   100        0.0005             nan     0.0500    0.0000
   120        0.0002             nan     0.0500   -0.0000
   140        0.0001             nan     0.0500    0.0000
   160        0.0001             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold14: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold14: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0400             nan     0.0500    0.0033
     2        0.0374             nan     0.0500    0.0024
     3        0.0350             nan     0.0500    0.0013
     4        0.0332             nan     0.0500    0.0017
     5        0.0306             nan     0.0500    0.0017
     6        0.0284             nan     0.0500    0.0017
     7        0.0259             nan     0.0500    0.0014
     8        0.0240             nan     0.0500    0.0016
     9        0.0227             nan     0.0500    0.0012
    10        0.0214             nan     0.0500    0.0015
    20        0.0105             nan     0.0500    0.0006
    40        0.0037             nan     0.0500    0.0000
    60        0.0015             nan     0.0500    0.0000
    80        0.0008             nan     0.0500   -0.0000
   100        0.0005             nan     0.0500   -0.0000
   120        0.0002             nan     0.0500   -0.0000
   140        0.0001             nan     0.0500    0.0000
   160        0.0001             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold14: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold14: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0400             nan     0.0500    0.0026
     2        0.0376             nan     0.0500    0.0020
     3        0.0353             nan     0.0500    0.0007
     4        0.0337             nan     0.0500    0.0016
     5        0.0315             nan     0.0500    0.0006
     6        0.0293             nan     0.0500    0.0008
     7        0.0277             nan     0.0500    0.0015
     8        0.0257             nan     0.0500    0.0016
     9        0.0239             nan     0.0500    0.0016
    10        0.0235             nan     0.0500    0.0000
    20        0.0153             nan     0.0500   -0.0002
    40        0.0089             nan     0.0500    0.0001
    60        0.0051             nan     0.0500    0.0001
    80        0.0034             nan     0.0500    0.0000
   100        0.0024             nan     0.0500    0.0000
   120        0.0017             nan     0.0500   -0.0000
   140        0.0011             nan     0.0500    0.0000
   160        0.0008             nan     0.0500   -0.0000
   180        0.0005             nan     0.0500   -0.0000
   200        0.0003             nan     0.0500    0.0000

- Fold14: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold14: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0401             nan     0.0500    0.0023
     2        0.0381             nan     0.0500    0.0017
     3        0.0355             nan     0.0500    0.0019
     4        0.0328             nan     0.0500    0.0004
     5        0.0302             nan     0.0500    0.0017
     6        0.0280             nan     0.0500    0.0006
     7        0.0262             nan     0.0500    0.0009
     8        0.0244             nan     0.0500    0.0018
     9        0.0234             nan     0.0500    0.0002
    10        0.0225             nan     0.0500    0.0002
    20        0.0103             nan     0.0500    0.0007
    40        0.0031             nan     0.0500    0.0000
    60        0.0012             nan     0.0500   -0.0000
    80        0.0005             nan     0.0500   -0.0000
   100        0.0002             nan     0.0500   -0.0000
   120        0.0001             nan     0.0500    0.0000
   140        0.0000             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold14: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold14: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0400             nan     0.0500    0.0027
     2        0.0374             nan     0.0500    0.0015
     3        0.0341             nan     0.0500    0.0021
     4        0.0315             nan     0.0500    0.0015
     5        0.0288             nan     0.0500    0.0022
     6        0.0273             nan     0.0500    0.0009
     7        0.0252             nan     0.0500    0.0019
     8        0.0233             nan     0.0500    0.0013
     9        0.0214             nan     0.0500    0.0015
    10        0.0195             nan     0.0500    0.0009
    20        0.0117             nan     0.0500   -0.0000
    40        0.0037             nan     0.0500    0.0001
    60        0.0013             nan     0.0500    0.0001
    80        0.0006             nan     0.0500   -0.0000
   100        0.0003             nan     0.0500    0.0000
   120        0.0002             nan     0.0500    0.0000
   140        0.0001             nan     0.0500   -0.0000
   160        0.0001             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500    0.0000

- Fold14: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold14: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0410             nan     0.0500    0.0010
     2        0.0388             nan     0.0500    0.0023
     3        0.0363             nan     0.0500    0.0027
     4        0.0345             nan     0.0500    0.0009
     5        0.0320             nan     0.0500    0.0023
     6        0.0307             nan     0.0500    0.0013
     7        0.0289             nan     0.0500    0.0019
     8        0.0275             nan     0.0500    0.0016
     9        0.0268             nan     0.0500   -0.0003
    10        0.0255             nan     0.0500    0.0014
    20        0.0172             nan     0.0500   -0.0001
    40        0.0079             nan     0.0500    0.0001
    60        0.0051             nan     0.0500   -0.0001
    80        0.0037             nan     0.0500   -0.0001
   100        0.0027             nan     0.0500   -0.0000
   120        0.0018             nan     0.0500    0.0000
   140        0.0013             nan     0.0500    0.0000
   160        0.0009             nan     0.0500    0.0000
   180        0.0006             nan     0.0500   -0.0000
   200        0.0005             nan     0.0500   -0.0000

- Fold14: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold14: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0393             nan     0.1000    0.0054
     2        0.0338             nan     0.1000    0.0052
     3        0.0311             nan     0.1000    0.0027
     4        0.0276             nan     0.1000    0.0018
     5        0.0236             nan     0.1000    0.0033
     6        0.0205             nan     0.1000    0.0013
     7        0.0183             nan     0.1000    0.0001
     8        0.0160             nan     0.1000    0.0018
     9        0.0145             nan     0.1000    0.0006
    10        0.0126             nan     0.1000    0.0012
    20        0.0052             nan     0.1000    0.0002
    40        0.0014             nan     0.1000   -0.0001
    60        0.0005             nan     0.1000   -0.0000
    80        0.0002             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000    0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold14: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold14: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0374             nan     0.1000    0.0045
     2        0.0320             nan     0.1000    0.0030
     3        0.0279             nan     0.1000    0.0040
     4        0.0258             nan     0.1000    0.0015
     5        0.0238             nan     0.1000    0.0014
     6        0.0213             nan     0.1000    0.0024
     7        0.0194             nan     0.1000    0.0007
     8        0.0183             nan     0.1000    0.0005
     9        0.0165             nan     0.1000    0.0019
    10        0.0151             nan     0.1000    0.0010
    20        0.0057             nan     0.1000    0.0005
    40        0.0016             nan     0.1000   -0.0000
    60        0.0005             nan     0.1000   -0.0000
    80        0.0002             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000    0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold14: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold14: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0379             nan     0.1000    0.0050
     2        0.0341             nan     0.1000    0.0040
     3        0.0318             nan     0.1000    0.0020
     4        0.0291             nan     0.1000    0.0006
     5        0.0250             nan     0.1000    0.0029
     6        0.0221             nan     0.1000    0.0028
     7        0.0205             nan     0.1000    0.0015
     8        0.0190             nan     0.1000    0.0018
     9        0.0178             nan     0.1000    0.0004
    10        0.0169             nan     0.1000    0.0008
    20        0.0101             nan     0.1000    0.0002
    40        0.0046             nan     0.1000   -0.0003
    60        0.0018             nan     0.1000    0.0000
    80        0.0009             nan     0.1000    0.0000
   100        0.0005             nan     0.1000    0.0000
   120        0.0003             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000    0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold14: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold14: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0371             nan     0.1000    0.0046
     2        0.0322             nan     0.1000    0.0048
     3        0.0264             nan     0.1000    0.0040
     4        0.0255             nan     0.1000    0.0004
     5        0.0230             nan     0.1000    0.0002
     6        0.0195             nan     0.1000    0.0028
     7        0.0169             nan     0.1000    0.0014
     8        0.0154             nan     0.1000    0.0014
     9        0.0125             nan     0.1000    0.0020
    10        0.0118             nan     0.1000   -0.0001
    20        0.0045             nan     0.1000    0.0002
    40        0.0009             nan     0.1000    0.0000
    60        0.0002             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000    0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000    0.0000
   180        0.0000             nan     0.1000    0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold14: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold14: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0392             nan     0.1000    0.0033
     2        0.0359             nan     0.1000    0.0038
     3        0.0315             nan     0.1000    0.0042
     4        0.0268             nan     0.1000    0.0028
     5        0.0244             nan     0.1000    0.0017
     6        0.0230             nan     0.1000    0.0017
     7        0.0201             nan     0.1000    0.0028
     8        0.0186             nan     0.1000    0.0007
     9        0.0170             nan     0.1000    0.0011
    10        0.0147             nan     0.1000    0.0015
    20        0.0064             nan     0.1000    0.0002
    40        0.0010             nan     0.1000   -0.0000
    60        0.0002             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold14: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold14: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0391             nan     0.1000    0.0050
     2        0.0342             nan     0.1000    0.0020
     3        0.0296             nan     0.1000    0.0034
     4        0.0267             nan     0.1000    0.0024
     5        0.0237             nan     0.1000    0.0028
     6        0.0211             nan     0.1000    0.0022
     7        0.0193             nan     0.1000    0.0019
     8        0.0167             nan     0.1000    0.0018
     9        0.0155             nan     0.1000    0.0007
    10        0.0148             nan     0.1000    0.0002
    20        0.0072             nan     0.1000    0.0002
    40        0.0029             nan     0.1000   -0.0001
    60        0.0015             nan     0.1000   -0.0000
    80        0.0009             nan     0.1000   -0.0000
   100        0.0005             nan     0.1000   -0.0000
   120        0.0003             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000    0.0000

- Fold14: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold14: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0356             nan     0.1000    0.0056
     2        0.0307             nan     0.1000    0.0033
     3        0.0257             nan     0.1000    0.0047
     4        0.0242             nan     0.1000   -0.0000
     5        0.0204             nan     0.1000    0.0015
     6        0.0171             nan     0.1000    0.0023
     7        0.0150             nan     0.1000    0.0011
     8        0.0137             nan     0.1000    0.0006
     9        0.0114             nan     0.1000    0.0008
    10        0.0102             nan     0.1000    0.0014
    20        0.0033             nan     0.1000    0.0001
    40        0.0004             nan     0.1000    0.0000
    60        0.0001             nan     0.1000    0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold14: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold14: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0377             nan     0.1000    0.0057
     2        0.0328             nan     0.1000    0.0055
     3        0.0282             nan     0.1000    0.0017
     4        0.0247             nan     0.1000    0.0020
     5        0.0207             nan     0.1000    0.0034
     6        0.0185             nan     0.1000    0.0016
     7        0.0164             nan     0.1000    0.0009
     8        0.0143             nan     0.1000    0.0022
     9        0.0127             nan     0.1000    0.0007
    10        0.0110             nan     0.1000    0.0011
    20        0.0035             nan     0.1000    0.0002
    40        0.0008             nan     0.1000   -0.0001
    60        0.0002             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000    0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold14: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold14: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0402             nan     0.1000    0.0021
     2        0.0346             nan     0.1000    0.0052
     3        0.0304             nan     0.1000    0.0033
     4        0.0266             nan     0.1000    0.0035
     5        0.0246             nan     0.1000    0.0007
     6        0.0220             nan     0.1000    0.0017
     7        0.0207             nan     0.1000    0.0007
     8        0.0197             nan     0.1000    0.0002
     9        0.0183             nan     0.1000   -0.0001
    10        0.0168             nan     0.1000    0.0004
    20        0.0097             nan     0.1000   -0.0002
    40        0.0037             nan     0.1000   -0.0002
    60        0.0014             nan     0.1000   -0.0001
    80        0.0008             nan     0.1000   -0.0000
   100        0.0005             nan     0.1000   -0.0000
   120        0.0003             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000    0.0000

- Fold14: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold15: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0366             nan     0.0100    0.0005
     2        0.0361             nan     0.0100    0.0004
     3        0.0356             nan     0.0100    0.0001
     4        0.0352             nan     0.0100    0.0001
     5        0.0347             nan     0.0100    0.0005
     6        0.0343             nan     0.0100    0.0004
     7        0.0338             nan     0.0100    0.0004
     8        0.0334             nan     0.0100    0.0003
     9        0.0328             nan     0.0100    0.0005
    10        0.0324             nan     0.0100    0.0003
    20        0.0286             nan     0.0100    0.0004
    40        0.0225             nan     0.0100    0.0001
    60        0.0185             nan     0.0100    0.0002
    80        0.0154             nan     0.0100    0.0001
   100        0.0129             nan     0.0100    0.0000
   120        0.0106             nan     0.0100   -0.0000
   140        0.0089             nan     0.0100    0.0000
   160        0.0077             nan     0.0100    0.0000
   180        0.0066             nan     0.0100    0.0000
   200        0.0056             nan     0.0100    0.0000

- Fold15: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold15: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0365             nan     0.0100    0.0005
     2        0.0360             nan     0.0100    0.0005
     3        0.0354             nan     0.0100    0.0004
     4        0.0350             nan     0.0100    0.0003
     5        0.0347             nan     0.0100    0.0002
     6        0.0343             nan     0.0100    0.0005
     7        0.0340             nan     0.0100    0.0004
     8        0.0337             nan     0.0100    0.0000
     9        0.0333             nan     0.0100    0.0001
    10        0.0331             nan     0.0100    0.0001
    20        0.0296             nan     0.0100    0.0002
    40        0.0235             nan     0.0100    0.0003
    60        0.0192             nan     0.0100    0.0002
    80        0.0158             nan     0.0100   -0.0001
   100        0.0131             nan     0.0100   -0.0000
   120        0.0109             nan     0.0100   -0.0000
   140        0.0093             nan     0.0100   -0.0001
   160        0.0078             nan     0.0100    0.0001
   180        0.0067             nan     0.0100    0.0001
   200        0.0058             nan     0.0100    0.0000

- Fold15: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold15: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0367             nan     0.0100    0.0003
     2        0.0362             nan     0.0100    0.0002
     3        0.0358             nan     0.0100    0.0005
     4        0.0353             nan     0.0100    0.0004
     5        0.0347             nan     0.0100    0.0005
     6        0.0343             nan     0.0100    0.0003
     7        0.0338             nan     0.0100    0.0004
     8        0.0334             nan     0.0100    0.0003
     9        0.0331             nan     0.0100    0.0002
    10        0.0329             nan     0.0100    0.0001
    20        0.0292             nan     0.0100    0.0000
    40        0.0228             nan     0.0100    0.0002
    60        0.0187             nan     0.0100    0.0002
    80        0.0155             nan     0.0100    0.0001
   100        0.0129             nan     0.0100    0.0001
   120        0.0110             nan     0.0100    0.0000
   140        0.0095             nan     0.0100   -0.0000
   160        0.0082             nan     0.0100   -0.0000
   180        0.0073             nan     0.0100   -0.0000
   200        0.0065             nan     0.0100    0.0000

- Fold15: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold15: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0366             nan     0.0100    0.0002
     2        0.0362             nan     0.0100    0.0001
     3        0.0358             nan     0.0100    0.0004
     4        0.0354             nan     0.0100    0.0002
     5        0.0350             nan     0.0100    0.0004
     6        0.0347             nan     0.0100    0.0003
     7        0.0342             nan     0.0100    0.0004
     8        0.0337             nan     0.0100    0.0001
     9        0.0332             nan     0.0100    0.0001
    10        0.0329             nan     0.0100    0.0000
    20        0.0291             nan     0.0100    0.0002
    40        0.0218             nan     0.0100    0.0003
    60        0.0173             nan     0.0100    0.0001
    80        0.0139             nan     0.0100   -0.0000
   100        0.0110             nan     0.0100    0.0001
   120        0.0088             nan     0.0100    0.0001
   140        0.0069             nan     0.0100    0.0001
   160        0.0055             nan     0.0100   -0.0000
   180        0.0045             nan     0.0100    0.0000
   200        0.0037             nan     0.0100    0.0000

- Fold15: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold15: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0365             nan     0.0100    0.0005
     2        0.0359             nan     0.0100    0.0005
     3        0.0355             nan     0.0100    0.0001
     4        0.0351             nan     0.0100    0.0004
     5        0.0345             nan     0.0100    0.0004
     6        0.0341             nan     0.0100    0.0002
     7        0.0338             nan     0.0100    0.0004
     8        0.0332             nan     0.0100    0.0004
     9        0.0328             nan     0.0100    0.0004
    10        0.0322             nan     0.0100    0.0004
    20        0.0285             nan     0.0100    0.0003
    40        0.0218             nan     0.0100    0.0002
    60        0.0169             nan     0.0100    0.0001
    80        0.0135             nan     0.0100   -0.0000
   100        0.0108             nan     0.0100   -0.0000
   120        0.0089             nan     0.0100    0.0001
   140        0.0073             nan     0.0100    0.0000
   160        0.0060             nan     0.0100    0.0000
   180        0.0050             nan     0.0100    0.0000
   200        0.0042             nan     0.0100   -0.0000

- Fold15: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold15: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0367             nan     0.0100    0.0005
     2        0.0364             nan     0.0100    0.0002
     3        0.0358             nan     0.0100    0.0004
     4        0.0354             nan     0.0100    0.0003
     5        0.0349             nan     0.0100    0.0005
     6        0.0345             nan     0.0100    0.0004
     7        0.0339             nan     0.0100    0.0004
     8        0.0336             nan     0.0100    0.0003
     9        0.0331             nan     0.0100    0.0003
    10        0.0328             nan     0.0100    0.0002
    20        0.0296             nan     0.0100   -0.0001
    40        0.0240             nan     0.0100    0.0003
    60        0.0196             nan     0.0100    0.0001
    80        0.0159             nan     0.0100    0.0001
   100        0.0132             nan     0.0100    0.0001
   120        0.0114             nan     0.0100    0.0001
   140        0.0102             nan     0.0100    0.0001
   160        0.0089             nan     0.0100   -0.0000
   180        0.0080             nan     0.0100   -0.0000
   200        0.0072             nan     0.0100   -0.0000

- Fold15: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold15: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0365             nan     0.0100    0.0007
     2        0.0358             nan     0.0100    0.0006
     3        0.0350             nan     0.0100    0.0005
     4        0.0343             nan     0.0100    0.0003
     5        0.0338             nan     0.0100    0.0005
     6        0.0331             nan     0.0100    0.0006
     7        0.0328             nan     0.0100    0.0000
     8        0.0322             nan     0.0100    0.0004
     9        0.0318             nan     0.0100    0.0002
    10        0.0313             nan     0.0100    0.0002
    20        0.0274             nan     0.0100    0.0002
    40        0.0207             nan     0.0100    0.0002
    60        0.0159             nan     0.0100   -0.0000
    80        0.0122             nan     0.0100    0.0001
   100        0.0094             nan     0.0100   -0.0000
   120        0.0074             nan     0.0100    0.0001
   140        0.0058             nan     0.0100    0.0001
   160        0.0045             nan     0.0100    0.0000
   180        0.0036             nan     0.0100    0.0000
   200        0.0029             nan     0.0100    0.0000

- Fold15: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold15: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0365             nan     0.0100    0.0004
     2        0.0358             nan     0.0100    0.0006
     3        0.0353             nan     0.0100    0.0004
     4        0.0347             nan     0.0100    0.0005
     5        0.0342             nan     0.0100    0.0005
     6        0.0339             nan     0.0100    0.0001
     7        0.0334             nan     0.0100    0.0001
     8        0.0329             nan     0.0100    0.0005
     9        0.0325             nan     0.0100    0.0003
    10        0.0321             nan     0.0100    0.0004
    20        0.0280             nan     0.0100    0.0002
    40        0.0215             nan     0.0100    0.0003
    60        0.0173             nan     0.0100    0.0000
    80        0.0136             nan     0.0100    0.0001
   100        0.0105             nan     0.0100    0.0001
   120        0.0084             nan     0.0100    0.0001
   140        0.0070             nan     0.0100    0.0001
   160        0.0057             nan     0.0100    0.0000
   180        0.0048             nan     0.0100    0.0000
   200        0.0040             nan     0.0100    0.0000

- Fold15: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold15: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0367             nan     0.0100    0.0004
     2        0.0363             nan     0.0100    0.0004
     3        0.0359             nan     0.0100    0.0003
     4        0.0355             nan     0.0100    0.0005
     5        0.0349             nan     0.0100    0.0005
     6        0.0345             nan     0.0100    0.0002
     7        0.0339             nan     0.0100    0.0005
     8        0.0335             nan     0.0100    0.0002
     9        0.0333             nan     0.0100   -0.0000
    10        0.0329             nan     0.0100    0.0004
    20        0.0292             nan     0.0100    0.0003
    40        0.0237             nan     0.0100    0.0000
    60        0.0194             nan     0.0100    0.0001
    80        0.0160             nan     0.0100    0.0001
   100        0.0137             nan     0.0100    0.0001
   120        0.0118             nan     0.0100    0.0000
   140        0.0102             nan     0.0100   -0.0001
   160        0.0090             nan     0.0100    0.0000
   180        0.0079             nan     0.0100    0.0000
   200        0.0070             nan     0.0100   -0.0000

- Fold15: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold15: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0347             nan     0.0500    0.0024
     2        0.0334             nan     0.0500    0.0013
     3        0.0317             nan     0.0500    0.0020
     4        0.0300             nan     0.0500    0.0012
     5        0.0283             nan     0.0500    0.0015
     6        0.0265             nan     0.0500    0.0016
     7        0.0245             nan     0.0500    0.0012
     8        0.0230             nan     0.0500    0.0014
     9        0.0218             nan     0.0500    0.0004
    10        0.0205             nan     0.0500    0.0006
    20        0.0125             nan     0.0500    0.0003
    40        0.0058             nan     0.0500    0.0002
    60        0.0028             nan     0.0500   -0.0001
    80        0.0015             nan     0.0500   -0.0000
   100        0.0009             nan     0.0500   -0.0000
   120        0.0005             nan     0.0500   -0.0000
   140        0.0003             nan     0.0500    0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500    0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold15: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold15: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0346             nan     0.0500    0.0022
     2        0.0319             nan     0.0500    0.0016
     3        0.0290             nan     0.0500    0.0020
     4        0.0274             nan     0.0500    0.0009
     5        0.0258             nan     0.0500    0.0016
     6        0.0249             nan     0.0500    0.0009
     7        0.0236             nan     0.0500    0.0013
     8        0.0222             nan     0.0500    0.0014
     9        0.0209             nan     0.0500    0.0009
    10        0.0197             nan     0.0500    0.0011
    20        0.0131             nan     0.0500   -0.0002
    40        0.0061             nan     0.0500    0.0001
    60        0.0032             nan     0.0500    0.0001
    80        0.0019             nan     0.0500   -0.0001
   100        0.0011             nan     0.0500   -0.0000
   120        0.0007             nan     0.0500    0.0000
   140        0.0005             nan     0.0500   -0.0000
   160        0.0003             nan     0.0500    0.0000
   180        0.0002             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500    0.0000

- Fold15: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold15: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0349             nan     0.0500    0.0022
     2        0.0337             nan     0.0500   -0.0006
     3        0.0315             nan     0.0500    0.0017
     4        0.0292             nan     0.0500    0.0020
     5        0.0275             nan     0.0500    0.0018
     6        0.0262             nan     0.0500    0.0016
     7        0.0250             nan     0.0500    0.0015
     8        0.0248             nan     0.0500   -0.0009
     9        0.0233             nan     0.0500    0.0004
    10        0.0224             nan     0.0500    0.0007
    20        0.0141             nan     0.0500    0.0004
    40        0.0084             nan     0.0500   -0.0000
    60        0.0056             nan     0.0500    0.0001
    80        0.0041             nan     0.0500    0.0000
   100        0.0030             nan     0.0500   -0.0001
   120        0.0023             nan     0.0500   -0.0000
   140        0.0019             nan     0.0500   -0.0000
   160        0.0016             nan     0.0500   -0.0000
   180        0.0013             nan     0.0500   -0.0000
   200        0.0009             nan     0.0500   -0.0000

- Fold15: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold15: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0346             nan     0.0500    0.0026
     2        0.0324             nan     0.0500    0.0019
     3        0.0311             nan     0.0500   -0.0005
     4        0.0292             nan     0.0500    0.0003
     5        0.0277             nan     0.0500    0.0000
     6        0.0262             nan     0.0500    0.0008
     7        0.0240             nan     0.0500    0.0016
     8        0.0220             nan     0.0500    0.0016
     9        0.0202             nan     0.0500    0.0012
    10        0.0189             nan     0.0500    0.0012
    20        0.0107             nan     0.0500    0.0004
    40        0.0035             nan     0.0500    0.0001
    60        0.0015             nan     0.0500   -0.0001
    80        0.0007             nan     0.0500   -0.0000
   100        0.0004             nan     0.0500   -0.0000
   120        0.0002             nan     0.0500    0.0000
   140        0.0001             nan     0.0500   -0.0000
   160        0.0001             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold15: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold15: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0348             nan     0.0500    0.0022
     2        0.0326             nan     0.0500    0.0025
     3        0.0301             nan     0.0500    0.0018
     4        0.0285             nan     0.0500    0.0009
     5        0.0260             nan     0.0500    0.0018
     6        0.0253             nan     0.0500   -0.0005
     7        0.0237             nan     0.0500    0.0017
     8        0.0230             nan     0.0500    0.0004
     9        0.0217             nan     0.0500    0.0009
    10        0.0203             nan     0.0500    0.0014
    20        0.0110             nan     0.0500    0.0002
    40        0.0041             nan     0.0500    0.0001
    60        0.0019             nan     0.0500    0.0000
    80        0.0010             nan     0.0500   -0.0000
   100        0.0007             nan     0.0500   -0.0000
   120        0.0004             nan     0.0500    0.0000
   140        0.0003             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500    0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500    0.0000

- Fold15: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold15: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0350             nan     0.0500    0.0012
     2        0.0339             nan     0.0500    0.0000
     3        0.0315             nan     0.0500    0.0022
     4        0.0294             nan     0.0500    0.0019
     5        0.0281             nan     0.0500    0.0008
     6        0.0265             nan     0.0500    0.0018
     7        0.0248             nan     0.0500    0.0014
     8        0.0228             nan     0.0500    0.0015
     9        0.0222             nan     0.0500   -0.0002
    10        0.0210             nan     0.0500    0.0006
    20        0.0128             nan     0.0500    0.0006
    40        0.0077             nan     0.0500    0.0001
    60        0.0048             nan     0.0500   -0.0000
    80        0.0034             nan     0.0500    0.0001
   100        0.0026             nan     0.0500   -0.0001
   120        0.0018             nan     0.0500    0.0000
   140        0.0014             nan     0.0500    0.0000
   160        0.0011             nan     0.0500   -0.0000
   180        0.0008             nan     0.0500   -0.0000
   200        0.0007             nan     0.0500   -0.0000

- Fold15: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold15: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0340             nan     0.0500    0.0023
     2        0.0314             nan     0.0500    0.0009
     3        0.0288             nan     0.0500    0.0020
     4        0.0261             nan     0.0500    0.0024
     5        0.0239             nan     0.0500    0.0016
     6        0.0233             nan     0.0500    0.0003
     7        0.0217             nan     0.0500    0.0014
     8        0.0209             nan     0.0500    0.0002
     9        0.0194             nan     0.0500    0.0014
    10        0.0181             nan     0.0500    0.0012
    20        0.0096             nan     0.0500    0.0006
    40        0.0029             nan     0.0500    0.0000
    60        0.0011             nan     0.0500    0.0000
    80        0.0005             nan     0.0500    0.0000
   100        0.0002             nan     0.0500   -0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0001             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500    0.0000

- Fold15: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold15: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0355             nan     0.0500    0.0006
     2        0.0338             nan     0.0500    0.0013
     3        0.0324             nan     0.0500    0.0008
     4        0.0301             nan     0.0500    0.0016
     5        0.0279             nan     0.0500    0.0019
     6        0.0263             nan     0.0500    0.0010
     7        0.0243             nan     0.0500    0.0012
     8        0.0223             nan     0.0500    0.0015
     9        0.0212             nan     0.0500    0.0006
    10        0.0200             nan     0.0500    0.0008
    20        0.0114             nan     0.0500    0.0005
    40        0.0042             nan     0.0500   -0.0000
    60        0.0020             nan     0.0500    0.0000
    80        0.0010             nan     0.0500   -0.0000
   100        0.0006             nan     0.0500    0.0000
   120        0.0005             nan     0.0500   -0.0000
   140        0.0004             nan     0.0500   -0.0000
   160        0.0003             nan     0.0500    0.0000
   180        0.0002             nan     0.0500   -0.0000
   200        0.0002             nan     0.0500   -0.0000

- Fold15: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold15: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0352             nan     0.0500    0.0009
     2        0.0329             nan     0.0500    0.0018
     3        0.0315             nan     0.0500    0.0018
     4        0.0292             nan     0.0500    0.0020
     5        0.0273             nan     0.0500    0.0017
     6        0.0261             nan     0.0500    0.0008
     7        0.0244             nan     0.0500    0.0007
     8        0.0225             nan     0.0500    0.0014
     9        0.0211             nan     0.0500    0.0012
    10        0.0201             nan     0.0500    0.0007
    20        0.0144             nan     0.0500   -0.0004
    40        0.0076             nan     0.0500    0.0001
    60        0.0051             nan     0.0500   -0.0000
    80        0.0036             nan     0.0500   -0.0000
   100        0.0026             nan     0.0500    0.0000
   120        0.0019             nan     0.0500    0.0000
   140        0.0014             nan     0.0500   -0.0000
   160        0.0010             nan     0.0500   -0.0000
   180        0.0009             nan     0.0500   -0.0000
   200        0.0007             nan     0.0500   -0.0000

- Fold15: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold15: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0337             nan     0.1000    0.0035
     2        0.0312             nan     0.1000    0.0014
     3        0.0271             nan     0.1000    0.0037
     4        0.0242             nan     0.1000    0.0005
     5        0.0231             nan     0.1000    0.0000
     6        0.0206             nan     0.1000    0.0011
     7        0.0183             nan     0.1000    0.0013
     8        0.0172             nan     0.1000   -0.0000
     9        0.0155             nan     0.1000    0.0016
    10        0.0137             nan     0.1000    0.0005
    20        0.0060             nan     0.1000   -0.0001
    40        0.0015             nan     0.1000    0.0000
    60        0.0006             nan     0.1000   -0.0000
    80        0.0002             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000    0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold15: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold15: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0350             nan     0.1000   -0.0012
     2        0.0318             nan     0.1000    0.0014
     3        0.0284             nan     0.1000    0.0017
     4        0.0242             nan     0.1000    0.0035
     5        0.0228             nan     0.1000    0.0003
     6        0.0199             nan     0.1000    0.0015
     7        0.0178             nan     0.1000    0.0024
     8        0.0158             nan     0.1000    0.0013
     9        0.0146             nan     0.1000    0.0010
    10        0.0130             nan     0.1000    0.0005
    20        0.0057             nan     0.1000    0.0000
    40        0.0022             nan     0.1000   -0.0002
    60        0.0010             nan     0.1000    0.0000
    80        0.0005             nan     0.1000   -0.0000
   100        0.0002             nan     0.1000    0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000    0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold15: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold15: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0330             nan     0.1000    0.0039
     2        0.0292             nan     0.1000    0.0037
     3        0.0263             nan     0.1000    0.0013
     4        0.0229             nan     0.1000    0.0033
     5        0.0198             nan     0.1000    0.0027
     6        0.0181             nan     0.1000    0.0016
     7        0.0160             nan     0.1000    0.0019
     8        0.0150             nan     0.1000    0.0008
     9        0.0134             nan     0.1000    0.0009
    10        0.0119             nan     0.1000    0.0013
    20        0.0066             nan     0.1000    0.0003
    40        0.0035             nan     0.1000   -0.0000
    60        0.0019             nan     0.1000   -0.0000
    80        0.0012             nan     0.1000   -0.0000
   100        0.0008             nan     0.1000    0.0000
   120        0.0005             nan     0.1000   -0.0000
   140        0.0003             nan     0.1000    0.0000
   160        0.0002             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000    0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold15: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold15: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0327             nan     0.1000    0.0042
     2        0.0272             nan     0.1000    0.0029
     3        0.0235             nan     0.1000    0.0028
     4        0.0200             nan     0.1000    0.0035
     5        0.0174             nan     0.1000    0.0013
     6        0.0150             nan     0.1000    0.0015
     7        0.0135             nan     0.1000    0.0010
     8        0.0115             nan     0.1000    0.0014
     9        0.0098             nan     0.1000    0.0006
    10        0.0086             nan     0.1000    0.0007
    20        0.0029             nan     0.1000   -0.0001
    40        0.0005             nan     0.1000    0.0000
    60        0.0002             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000    0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold15: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold15: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0316             nan     0.1000    0.0046
     2        0.0277             nan     0.1000    0.0034
     3        0.0233             nan     0.1000    0.0033
     4        0.0211             nan     0.1000    0.0018
     5        0.0180             nan     0.1000    0.0016
     6        0.0161             nan     0.1000    0.0016
     7        0.0141             nan     0.1000    0.0011
     8        0.0130             nan     0.1000    0.0008
     9        0.0116             nan     0.1000    0.0006
    10        0.0107             nan     0.1000    0.0007
    20        0.0038             nan     0.1000   -0.0001
    40        0.0012             nan     0.1000    0.0000
    60        0.0004             nan     0.1000   -0.0000
    80        0.0002             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000    0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000    0.0000
   160        0.0000             nan     0.1000    0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000    0.0000

- Fold15: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold15: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0347             nan     0.1000    0.0005
     2        0.0300             nan     0.1000    0.0045
     3        0.0256             nan     0.1000    0.0035
     4        0.0232             nan     0.1000    0.0019
     5        0.0216             nan     0.1000    0.0014
     6        0.0206             nan     0.1000    0.0004
     7        0.0192             nan     0.1000    0.0006
     8        0.0169             nan     0.1000    0.0015
     9        0.0164             nan     0.1000   -0.0001
    10        0.0147             nan     0.1000    0.0010
    20        0.0076             nan     0.1000   -0.0003
    40        0.0035             nan     0.1000    0.0001
    60        0.0016             nan     0.1000   -0.0000
    80        0.0009             nan     0.1000   -0.0000
   100        0.0006             nan     0.1000   -0.0000
   120        0.0004             nan     0.1000    0.0000
   140        0.0003             nan     0.1000   -0.0000
   160        0.0002             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000    0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold15: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold15: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0318             nan     0.1000    0.0030
     2        0.0284             nan     0.1000    0.0022
     3        0.0245             nan     0.1000    0.0038
     4        0.0200             nan     0.1000    0.0026
     5        0.0170             nan     0.1000    0.0019
     6        0.0148             nan     0.1000    0.0009
     7        0.0136             nan     0.1000    0.0007
     8        0.0116             nan     0.1000    0.0021
     9        0.0102             nan     0.1000    0.0015
    10        0.0088             nan     0.1000    0.0010
    20        0.0025             nan     0.1000    0.0000
    40        0.0004             nan     0.1000   -0.0000
    60        0.0001             nan     0.1000   -0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000    0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold15: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold15: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0313             nan     0.1000    0.0025
     2        0.0272             nan     0.1000    0.0041
     3        0.0231             nan     0.1000    0.0043
     4        0.0201             nan     0.1000    0.0024
     5        0.0173             nan     0.1000    0.0016
     6        0.0147             nan     0.1000    0.0019
     7        0.0133             nan     0.1000    0.0004
     8        0.0121             nan     0.1000    0.0012
     9        0.0102             nan     0.1000    0.0007
    10        0.0093             nan     0.1000    0.0009
    20        0.0031             nan     0.1000    0.0001
    40        0.0009             nan     0.1000   -0.0000
    60        0.0003             nan     0.1000   -0.0000
    80        0.0002             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold15: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold15: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0318             nan     0.1000    0.0043
     2        0.0290             nan     0.1000    0.0028
     3        0.0252             nan     0.1000    0.0034
     4        0.0219             nan     0.1000    0.0024
     5        0.0194             nan     0.1000    0.0026
     6        0.0173             nan     0.1000    0.0003
     7        0.0161             nan     0.1000    0.0009
     8        0.0139             nan     0.1000    0.0009
     9        0.0129             nan     0.1000    0.0007
    10        0.0119             nan     0.1000    0.0009
    20        0.0063             nan     0.1000    0.0002
    40        0.0028             nan     0.1000   -0.0001
    60        0.0016             nan     0.1000   -0.0001
    80        0.0009             nan     0.1000    0.0000
   100        0.0005             nan     0.1000   -0.0000
   120        0.0003             nan     0.1000    0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000    0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold15: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold16: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0432             nan     0.0100    0.0006
     2        0.0425             nan     0.0100    0.0006
     3        0.0419             nan     0.0100    0.0004
     4        0.0413             nan     0.0100    0.0005
     5        0.0407             nan     0.0100    0.0003
     6        0.0403             nan     0.0100    0.0004
     7        0.0397             nan     0.0100    0.0004
     8        0.0392             nan     0.0100    0.0003
     9        0.0387             nan     0.0100    0.0002
    10        0.0384             nan     0.0100    0.0003
    20        0.0339             nan     0.0100    0.0004
    40        0.0268             nan     0.0100   -0.0000
    60        0.0218             nan     0.0100    0.0003
    80        0.0181             nan     0.0100    0.0000
   100        0.0147             nan     0.0100    0.0001
   120        0.0123             nan     0.0100    0.0001
   140        0.0103             nan     0.0100    0.0001
   160        0.0090             nan     0.0100    0.0001
   180        0.0076             nan     0.0100    0.0000
   200        0.0065             nan     0.0100    0.0000

- Fold16: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold16: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0434             nan     0.0100    0.0000
     2        0.0428             nan     0.0100    0.0005
     3        0.0423             nan     0.0100    0.0006
     4        0.0417             nan     0.0100    0.0005
     5        0.0413             nan     0.0100    0.0001
     6        0.0409             nan     0.0100    0.0003
     7        0.0404             nan     0.0100    0.0002
     8        0.0399             nan     0.0100    0.0003
     9        0.0393             nan     0.0100    0.0006
    10        0.0389             nan     0.0100    0.0002
    20        0.0346             nan     0.0100    0.0002
    40        0.0276             nan     0.0100    0.0003
    60        0.0227             nan     0.0100    0.0002
    80        0.0185             nan     0.0100    0.0001
   100        0.0152             nan     0.0100    0.0001
   120        0.0127             nan     0.0100    0.0001
   140        0.0107             nan     0.0100    0.0001
   160        0.0091             nan     0.0100   -0.0001
   180        0.0079             nan     0.0100    0.0001
   200        0.0069             nan     0.0100    0.0000

- Fold16: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold16: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0433             nan     0.0100    0.0002
     2        0.0428             nan     0.0100    0.0002
     3        0.0423             nan     0.0100    0.0002
     4        0.0418             nan     0.0100    0.0003
     5        0.0412             nan     0.0100    0.0005
     6        0.0407             nan     0.0100    0.0005
     7        0.0402             nan     0.0100    0.0003
     8        0.0397             nan     0.0100    0.0003
     9        0.0393             nan     0.0100    0.0003
    10        0.0388             nan     0.0100    0.0002
    20        0.0345             nan     0.0100    0.0002
    40        0.0279             nan     0.0100    0.0004
    60        0.0224             nan     0.0100    0.0001
    80        0.0190             nan     0.0100    0.0002
   100        0.0161             nan     0.0100    0.0000
   120        0.0139             nan     0.0100    0.0001
   140        0.0121             nan     0.0100    0.0001
   160        0.0108             nan     0.0100    0.0001
   180        0.0098             nan     0.0100    0.0000
   200        0.0087             nan     0.0100    0.0000

- Fold16: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold16: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0434             nan     0.0100    0.0000
     2        0.0430             nan     0.0100    0.0005
     3        0.0423             nan     0.0100    0.0004
     4        0.0419             nan     0.0100    0.0002
     5        0.0414             nan     0.0100    0.0003
     6        0.0411             nan     0.0100   -0.0000
     7        0.0405             nan     0.0100    0.0002
     8        0.0399             nan     0.0100    0.0003
     9        0.0395             nan     0.0100    0.0001
    10        0.0390             nan     0.0100    0.0004
    20        0.0335             nan     0.0100    0.0005
    40        0.0256             nan     0.0100    0.0004
    60        0.0195             nan     0.0100    0.0002
    80        0.0150             nan     0.0100    0.0001
   100        0.0117             nan     0.0100    0.0000
   120        0.0092             nan     0.0100    0.0001
   140        0.0072             nan     0.0100    0.0001
   160        0.0058             nan     0.0100    0.0000
   180        0.0048             nan     0.0100    0.0000
   200        0.0039             nan     0.0100    0.0000

- Fold16: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold16: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0434             nan     0.0100   -0.0000
     2        0.0428             nan     0.0100    0.0005
     3        0.0422             nan     0.0100    0.0007
     4        0.0416             nan     0.0100    0.0005
     5        0.0411             nan     0.0100    0.0004
     6        0.0405             nan     0.0100    0.0003
     7        0.0398             nan     0.0100    0.0006
     8        0.0392             nan     0.0100    0.0006
     9        0.0388             nan     0.0100    0.0003
    10        0.0384             nan     0.0100    0.0003
    20        0.0336             nan     0.0100    0.0004
    40        0.0258             nan     0.0100    0.0003
    60        0.0199             nan     0.0100    0.0002
    80        0.0158             nan     0.0100    0.0001
   100        0.0129             nan     0.0100    0.0001
   120        0.0104             nan     0.0100    0.0000
   140        0.0083             nan     0.0100   -0.0000
   160        0.0068             nan     0.0100    0.0001
   180        0.0055             nan     0.0100    0.0000
   200        0.0046             nan     0.0100    0.0001

- Fold16: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold16: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0431             nan     0.0100    0.0005
     2        0.0426             nan     0.0100    0.0006
     3        0.0423             nan     0.0100   -0.0000
     4        0.0419             nan     0.0100    0.0003
     5        0.0414             nan     0.0100    0.0002
     6        0.0411             nan     0.0100   -0.0000
     7        0.0405             nan     0.0100    0.0005
     8        0.0400             nan     0.0100    0.0004
     9        0.0395             nan     0.0100    0.0003
    10        0.0391             nan     0.0100    0.0004
    20        0.0355             nan     0.0100    0.0003
    40        0.0277             nan     0.0100    0.0003
    60        0.0228             nan     0.0100    0.0002
    80        0.0187             nan     0.0100   -0.0001
   100        0.0160             nan     0.0100    0.0001
   120        0.0138             nan     0.0100    0.0001
   140        0.0119             nan     0.0100    0.0000
   160        0.0104             nan     0.0100    0.0000
   180        0.0089             nan     0.0100    0.0000
   200        0.0079             nan     0.0100    0.0000

- Fold16: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold16: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0431             nan     0.0100    0.0006
     2        0.0425             nan     0.0100    0.0003
     3        0.0419             nan     0.0100    0.0002
     4        0.0411             nan     0.0100    0.0006
     5        0.0407             nan     0.0100    0.0003
     6        0.0402             nan     0.0100    0.0006
     7        0.0397             nan     0.0100    0.0006
     8        0.0389             nan     0.0100    0.0008
     9        0.0382             nan     0.0100    0.0007
    10        0.0376             nan     0.0100    0.0004
    20        0.0324             nan     0.0100    0.0003
    40        0.0240             nan     0.0100    0.0001
    60        0.0177             nan     0.0100    0.0001
    80        0.0136             nan     0.0100    0.0002
   100        0.0105             nan     0.0100    0.0000
   120        0.0083             nan     0.0100    0.0001
   140        0.0065             nan     0.0100    0.0001
   160        0.0050             nan     0.0100    0.0001
   180        0.0040             nan     0.0100    0.0000
   200        0.0031             nan     0.0100    0.0000

- Fold16: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold16: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0430             nan     0.0100    0.0004
     2        0.0422             nan     0.0100    0.0005
     3        0.0417             nan     0.0100    0.0006
     4        0.0411             nan     0.0100    0.0007
     5        0.0404             nan     0.0100    0.0006
     6        0.0398             nan     0.0100    0.0003
     7        0.0392             nan     0.0100    0.0003
     8        0.0387             nan     0.0100    0.0003
     9        0.0382             nan     0.0100    0.0006
    10        0.0375             nan     0.0100    0.0005
    20        0.0323             nan     0.0100    0.0004
    40        0.0248             nan     0.0100    0.0003
    60        0.0195             nan     0.0100    0.0000
    80        0.0151             nan     0.0100    0.0000
   100        0.0122             nan     0.0100    0.0000
   120        0.0097             nan     0.0100    0.0000
   140        0.0076             nan     0.0100    0.0001
   160        0.0061             nan     0.0100    0.0000
   180        0.0049             nan     0.0100    0.0000
   200        0.0042             nan     0.0100    0.0000

- Fold16: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold16: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0433             nan     0.0100    0.0005
     2        0.0426             nan     0.0100    0.0005
     3        0.0420             nan     0.0100    0.0005
     4        0.0416             nan     0.0100    0.0004
     5        0.0411             nan     0.0100    0.0003
     6        0.0406             nan     0.0100    0.0005
     7        0.0400             nan     0.0100    0.0006
     8        0.0395             nan     0.0100    0.0004
     9        0.0393             nan     0.0100    0.0000
    10        0.0389             nan     0.0100    0.0004
    20        0.0351             nan     0.0100    0.0004
    40        0.0279             nan     0.0100    0.0001
    60        0.0229             nan     0.0100    0.0002
    80        0.0195             nan     0.0100    0.0000
   100        0.0167             nan     0.0100   -0.0000
   120        0.0142             nan     0.0100    0.0001
   140        0.0123             nan     0.0100    0.0000
   160        0.0109             nan     0.0100   -0.0000
   180        0.0096             nan     0.0100    0.0000
   200        0.0086             nan     0.0100    0.0000

- Fold16: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold16: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0419             nan     0.0500    0.0009
     2        0.0397             nan     0.0500    0.0021
     3        0.0373             nan     0.0500    0.0025
     4        0.0351             nan     0.0500    0.0012
     5        0.0329             nan     0.0500    0.0020
     6        0.0306             nan     0.0500    0.0015
     7        0.0284             nan     0.0500    0.0021
     8        0.0272             nan     0.0500    0.0008
     9        0.0266             nan     0.0500    0.0000
    10        0.0248             nan     0.0500    0.0015
    20        0.0155             nan     0.0500    0.0004
    40        0.0067             nan     0.0500    0.0001
    60        0.0031             nan     0.0500    0.0000
    80        0.0018             nan     0.0500    0.0000
   100        0.0010             nan     0.0500    0.0000
   120        0.0006             nan     0.0500   -0.0000
   140        0.0004             nan     0.0500   -0.0000
   160        0.0003             nan     0.0500   -0.0000
   180        0.0002             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold16: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold16: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0414             nan     0.0500    0.0026
     2        0.0385             nan     0.0500    0.0020
     3        0.0362             nan     0.0500    0.0007
     4        0.0344             nan     0.0500    0.0018
     5        0.0319             nan     0.0500    0.0023
     6        0.0299             nan     0.0500    0.0021
     7        0.0279             nan     0.0500    0.0017
     8        0.0262             nan     0.0500    0.0017
     9        0.0250             nan     0.0500    0.0003
    10        0.0239             nan     0.0500    0.0001
    20        0.0137             nan     0.0500    0.0005
    40        0.0059             nan     0.0500    0.0001
    60        0.0031             nan     0.0500    0.0001
    80        0.0018             nan     0.0500   -0.0000
   100        0.0011             nan     0.0500   -0.0000
   120        0.0006             nan     0.0500    0.0000
   140        0.0004             nan     0.0500    0.0000
   160        0.0003             nan     0.0500   -0.0000
   180        0.0002             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500    0.0000

- Fold16: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold16: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0420             nan     0.0500    0.0012
     2        0.0392             nan     0.0500    0.0027
     3        0.0368             nan     0.0500    0.0019
     4        0.0349             nan     0.0500    0.0022
     5        0.0328             nan     0.0500    0.0021
     6        0.0310             nan     0.0500    0.0007
     7        0.0286             nan     0.0500    0.0016
     8        0.0276             nan     0.0500    0.0005
     9        0.0258             nan     0.0500    0.0014
    10        0.0247             nan     0.0500    0.0001
    20        0.0141             nan     0.0500    0.0004
    40        0.0075             nan     0.0500    0.0000
    60        0.0045             nan     0.0500   -0.0001
    80        0.0029             nan     0.0500    0.0000
   100        0.0019             nan     0.0500   -0.0000
   120        0.0013             nan     0.0500   -0.0000
   140        0.0009             nan     0.0500   -0.0000
   160        0.0006             nan     0.0500   -0.0000
   180        0.0004             nan     0.0500    0.0000
   200        0.0003             nan     0.0500   -0.0000

- Fold16: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold16: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0405             nan     0.0500    0.0010
     2        0.0383             nan     0.0500    0.0016
     3        0.0359             nan     0.0500    0.0020
     4        0.0325             nan     0.0500    0.0028
     5        0.0308             nan     0.0500    0.0008
     6        0.0290             nan     0.0500    0.0015
     7        0.0267             nan     0.0500    0.0018
     8        0.0252             nan     0.0500    0.0003
     9        0.0234             nan     0.0500    0.0005
    10        0.0220             nan     0.0500    0.0011
    20        0.0127             nan     0.0500    0.0004
    40        0.0046             nan     0.0500   -0.0000
    60        0.0020             nan     0.0500    0.0000
    80        0.0008             nan     0.0500   -0.0001
   100        0.0004             nan     0.0500   -0.0000
   120        0.0002             nan     0.0500    0.0000
   140        0.0001             nan     0.0500    0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500    0.0000

- Fold16: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold16: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0394             nan     0.0500    0.0028
     2        0.0377             nan     0.0500    0.0011
     3        0.0350             nan     0.0500    0.0031
     4        0.0327             nan     0.0500    0.0012
     5        0.0307             nan     0.0500    0.0019
     6        0.0286             nan     0.0500    0.0014
     7        0.0265             nan     0.0500    0.0018
     8        0.0244             nan     0.0500    0.0016
     9        0.0227             nan     0.0500    0.0001
    10        0.0211             nan     0.0500    0.0014
    20        0.0116             nan     0.0500    0.0008
    40        0.0038             nan     0.0500    0.0002
    60        0.0018             nan     0.0500    0.0000
    80        0.0009             nan     0.0500    0.0000
   100        0.0005             nan     0.0500   -0.0000
   120        0.0003             nan     0.0500   -0.0000
   140        0.0002             nan     0.0500   -0.0000
   160        0.0001             nan     0.0500    0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500    0.0000

- Fold16: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold16: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0411             nan     0.0500    0.0022
     2        0.0388             nan     0.0500    0.0015
     3        0.0360             nan     0.0500    0.0026
     4        0.0337             nan     0.0500    0.0022
     5        0.0326             nan     0.0500   -0.0002
     6        0.0315             nan     0.0500    0.0011
     7        0.0298             nan     0.0500    0.0010
     8        0.0289             nan     0.0500    0.0012
     9        0.0275             nan     0.0500    0.0009
    10        0.0260             nan     0.0500    0.0013
    20        0.0155             nan     0.0500    0.0003
    40        0.0082             nan     0.0500    0.0001
    60        0.0049             nan     0.0500    0.0001
    80        0.0033             nan     0.0500    0.0000
   100        0.0023             nan     0.0500   -0.0001
   120        0.0017             nan     0.0500   -0.0000
   140        0.0013             nan     0.0500    0.0000
   160        0.0011             nan     0.0500    0.0000
   180        0.0008             nan     0.0500   -0.0000
   200        0.0007             nan     0.0500   -0.0000

- Fold16: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold16: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0413             nan     0.0500    0.0025
     2        0.0378             nan     0.0500    0.0031
     3        0.0368             nan     0.0500   -0.0007
     4        0.0350             nan     0.0500   -0.0001
     5        0.0334             nan     0.0500    0.0007
     6        0.0313             nan     0.0500    0.0012
     7        0.0304             nan     0.0500    0.0006
     8        0.0282             nan     0.0500    0.0023
     9        0.0264             nan     0.0500    0.0012
    10        0.0240             nan     0.0500    0.0018
    20        0.0116             nan     0.0500    0.0002
    40        0.0038             nan     0.0500   -0.0000
    60        0.0013             nan     0.0500    0.0000
    80        0.0005             nan     0.0500    0.0000
   100        0.0002             nan     0.0500   -0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0000             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold16: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold16: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0410             nan     0.0500    0.0023
     2        0.0382             nan     0.0500    0.0022
     3        0.0356             nan     0.0500    0.0024
     4        0.0326             nan     0.0500    0.0018
     5        0.0294             nan     0.0500    0.0023
     6        0.0276             nan     0.0500    0.0008
     7        0.0250             nan     0.0500    0.0019
     8        0.0242             nan     0.0500    0.0006
     9        0.0232             nan     0.0500    0.0008
    10        0.0220             nan     0.0500    0.0008
    20        0.0120             nan     0.0500    0.0007
    40        0.0043             nan     0.0500    0.0002
    60        0.0019             nan     0.0500   -0.0001
    80        0.0010             nan     0.0500    0.0000
   100        0.0006             nan     0.0500   -0.0000
   120        0.0004             nan     0.0500   -0.0000
   140        0.0003             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500    0.0000

- Fold16: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold16: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0407             nan     0.0500    0.0022
     2        0.0384             nan     0.0500    0.0020
     3        0.0369             nan     0.0500    0.0008
     4        0.0347             nan     0.0500    0.0019
     5        0.0330             nan     0.0500    0.0009
     6        0.0306             nan     0.0500    0.0018
     7        0.0298             nan     0.0500   -0.0005
     8        0.0281             nan     0.0500    0.0010
     9        0.0274             nan     0.0500   -0.0002
    10        0.0259             nan     0.0500    0.0010
    20        0.0157             nan     0.0500    0.0003
    40        0.0074             nan     0.0500    0.0002
    60        0.0043             nan     0.0500   -0.0002
    80        0.0029             nan     0.0500   -0.0000
   100        0.0018             nan     0.0500   -0.0000
   120        0.0012             nan     0.0500    0.0000
   140        0.0009             nan     0.0500   -0.0000
   160        0.0007             nan     0.0500    0.0000
   180        0.0005             nan     0.0500   -0.0000
   200        0.0004             nan     0.0500   -0.0000

- Fold16: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold16: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0397             nan     0.1000    0.0036
     2        0.0367             nan     0.1000    0.0027
     3        0.0344             nan     0.1000   -0.0003
     4        0.0310             nan     0.1000    0.0013
     5        0.0278             nan     0.1000    0.0006
     6        0.0253             nan     0.1000    0.0030
     7        0.0223             nan     0.1000    0.0024
     8        0.0204             nan     0.1000    0.0022
     9        0.0181             nan     0.1000    0.0006
    10        0.0165             nan     0.1000    0.0009
    20        0.0073             nan     0.1000    0.0005
    40        0.0023             nan     0.1000    0.0000
    60        0.0008             nan     0.1000   -0.0001
    80        0.0003             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000    0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold16: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold16: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0392             nan     0.1000    0.0053
     2        0.0342             nan     0.1000    0.0047
     3        0.0320             nan     0.1000    0.0016
     4        0.0294             nan     0.1000    0.0029
     5        0.0262             nan     0.1000    0.0027
     6        0.0237             nan     0.1000    0.0023
     7        0.0218             nan     0.1000    0.0015
     8        0.0193             nan     0.1000    0.0021
     9        0.0174             nan     0.1000    0.0019
    10        0.0160             nan     0.1000    0.0012
    20        0.0072             nan     0.1000   -0.0002
    40        0.0024             nan     0.1000   -0.0000
    60        0.0009             nan     0.1000    0.0000
    80        0.0004             nan     0.1000    0.0000
   100        0.0002             nan     0.1000   -0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000    0.0000
   160        0.0000             nan     0.1000    0.0000
   180        0.0000             nan     0.1000    0.0000
   200        0.0000             nan     0.1000    0.0000

- Fold16: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold16: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0371             nan     0.1000    0.0056
     2        0.0335             nan     0.1000    0.0018
     3        0.0294             nan     0.1000    0.0023
     4        0.0277             nan     0.1000   -0.0004
     5        0.0243             nan     0.1000    0.0031
     6        0.0230             nan     0.1000   -0.0003
     7        0.0205             nan     0.1000    0.0019
     8        0.0186             nan     0.1000    0.0005
     9        0.0169             nan     0.1000    0.0014
    10        0.0154             nan     0.1000    0.0008
    20        0.0081             nan     0.1000    0.0002
    40        0.0030             nan     0.1000    0.0001
    60        0.0017             nan     0.1000   -0.0001
    80        0.0009             nan     0.1000   -0.0001
   100        0.0005             nan     0.1000   -0.0000
   120        0.0003             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold16: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold16: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0370             nan     0.1000    0.0054
     2        0.0331             nan     0.1000    0.0032
     3        0.0273             nan     0.1000    0.0066
     4        0.0229             nan     0.1000    0.0028
     5        0.0194             nan     0.1000    0.0034
     6        0.0157             nan     0.1000    0.0027
     7        0.0135             nan     0.1000    0.0020
     8        0.0126             nan     0.1000    0.0001
     9        0.0117             nan     0.1000    0.0002
    10        0.0098             nan     0.1000    0.0013
    20        0.0031             nan     0.1000    0.0003
    40        0.0005             nan     0.1000    0.0000
    60        0.0001             nan     0.1000   -0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000    0.0000
   140        0.0000             nan     0.1000    0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold16: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold16: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0370             nan     0.1000    0.0040
     2        0.0324             nan     0.1000    0.0033
     3        0.0270             nan     0.1000    0.0044
     4        0.0243             nan     0.1000    0.0016
     5        0.0219             nan     0.1000    0.0011
     6        0.0189             nan     0.1000    0.0025
     7        0.0179             nan     0.1000    0.0000
     8        0.0163             nan     0.1000   -0.0000
     9        0.0145             nan     0.1000    0.0002
    10        0.0134             nan     0.1000    0.0005
    20        0.0046             nan     0.1000    0.0003
    40        0.0010             nan     0.1000   -0.0000
    60        0.0004             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000    0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold16: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold16: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0385             nan     0.1000    0.0053
     2        0.0350             nan     0.1000    0.0043
     3        0.0319             nan     0.1000    0.0028
     4        0.0295             nan     0.1000    0.0020
     5        0.0261             nan     0.1000    0.0031
     6        0.0238             nan     0.1000    0.0017
     7        0.0224             nan     0.1000    0.0014
     8        0.0202             nan     0.1000    0.0018
     9        0.0179             nan     0.1000    0.0008
    10        0.0165             nan     0.1000    0.0014
    20        0.0089             nan     0.1000   -0.0001
    40        0.0041             nan     0.1000    0.0002
    60        0.0020             nan     0.1000   -0.0002
    80        0.0011             nan     0.1000   -0.0000
   100        0.0006             nan     0.1000    0.0000
   120        0.0004             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold16: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold16: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0376             nan     0.1000    0.0058
     2        0.0341             nan     0.1000    0.0003
     3        0.0294             nan     0.1000    0.0033
     4        0.0281             nan     0.1000   -0.0015
     5        0.0227             nan     0.1000    0.0054
     6        0.0203             nan     0.1000    0.0008
     7        0.0179             nan     0.1000    0.0016
     8        0.0152             nan     0.1000    0.0019
     9        0.0128             nan     0.1000    0.0023
    10        0.0122             nan     0.1000    0.0003
    20        0.0043             nan     0.1000    0.0002
    40        0.0006             nan     0.1000    0.0000
    60        0.0001             nan     0.1000    0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold16: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold16: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0384             nan     0.1000    0.0022
     2        0.0318             nan     0.1000    0.0050
     3        0.0269             nan     0.1000    0.0022
     4        0.0237             nan     0.1000    0.0023
     5        0.0199             nan     0.1000    0.0032
     6        0.0175             nan     0.1000    0.0013
     7        0.0155             nan     0.1000    0.0020
     8        0.0142             nan     0.1000    0.0002
     9        0.0126             nan     0.1000    0.0006
    10        0.0119             nan     0.1000    0.0000
    20        0.0046             nan     0.1000    0.0002
    40        0.0011             nan     0.1000   -0.0000
    60        0.0003             nan     0.1000    0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000    0.0000
   160        0.0000             nan     0.1000    0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000    0.0000

- Fold16: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold16: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0383             nan     0.1000    0.0060
     2        0.0344             nan     0.1000    0.0023
     3        0.0317             nan     0.1000    0.0024
     4        0.0293             nan     0.1000    0.0020
     5        0.0271             nan     0.1000    0.0002
     6        0.0248             nan     0.1000    0.0015
     7        0.0214             nan     0.1000    0.0020
     8        0.0199             nan     0.1000    0.0007
     9        0.0187             nan     0.1000    0.0015
    10        0.0174             nan     0.1000    0.0002
    20        0.0093             nan     0.1000    0.0004
    40        0.0041             nan     0.1000   -0.0001
    60        0.0025             nan     0.1000    0.0001
    80        0.0016             nan     0.1000   -0.0002
   100        0.0008             nan     0.1000    0.0000
   120        0.0005             nan     0.1000    0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000    0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold16: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold17: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0434             nan     0.0100    0.0005
     2        0.0428             nan     0.0100    0.0005
     3        0.0421             nan     0.0100    0.0005
     4        0.0415             nan     0.0100    0.0006
     5        0.0412             nan     0.0100    0.0002
     6        0.0407             nan     0.0100    0.0005
     7        0.0405             nan     0.0100   -0.0000
     8        0.0400             nan     0.0100    0.0005
     9        0.0395             nan     0.0100    0.0002
    10        0.0390             nan     0.0100    0.0006
    20        0.0339             nan     0.0100    0.0001
    40        0.0264             nan     0.0100    0.0002
    60        0.0207             nan     0.0100    0.0002
    80        0.0168             nan     0.0100    0.0001
   100        0.0132             nan     0.0100    0.0002
   120        0.0107             nan     0.0100   -0.0000
   140        0.0089             nan     0.0100   -0.0000
   160        0.0074             nan     0.0100   -0.0000
   180        0.0062             nan     0.0100    0.0000
   200        0.0052             nan     0.0100    0.0000

- Fold17: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold17: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0434             nan     0.0100    0.0004
     2        0.0428             nan     0.0100    0.0006
     3        0.0423             nan     0.0100    0.0005
     4        0.0418             nan     0.0100    0.0006
     5        0.0412             nan     0.0100    0.0006
     6        0.0410             nan     0.0100   -0.0001
     7        0.0405             nan     0.0100    0.0006
     8        0.0399             nan     0.0100    0.0004
     9        0.0395             nan     0.0100    0.0005
    10        0.0389             nan     0.0100    0.0005
    20        0.0343             nan     0.0100    0.0002
    40        0.0274             nan     0.0100    0.0003
    60        0.0220             nan     0.0100    0.0000
    80        0.0177             nan     0.0100    0.0002
   100        0.0148             nan     0.0100    0.0001
   120        0.0121             nan     0.0100   -0.0000
   140        0.0098             nan     0.0100    0.0000
   160        0.0082             nan     0.0100    0.0000
   180        0.0069             nan     0.0100   -0.0000
   200        0.0059             nan     0.0100    0.0000

- Fold17: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold17: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0434             nan     0.0100    0.0006
     2        0.0428             nan     0.0100    0.0006
     3        0.0423             nan     0.0100    0.0004
     4        0.0417             nan     0.0100    0.0005
     5        0.0413             nan     0.0100    0.0005
     6        0.0407             nan     0.0100    0.0005
     7        0.0405             nan     0.0100    0.0001
     8        0.0400             nan     0.0100    0.0003
     9        0.0395             nan     0.0100    0.0005
    10        0.0390             nan     0.0100    0.0005
    20        0.0346             nan     0.0100    0.0004
    40        0.0280             nan     0.0100    0.0001
    60        0.0229             nan     0.0100    0.0001
    80        0.0189             nan     0.0100    0.0001
   100        0.0158             nan     0.0100    0.0001
   120        0.0135             nan     0.0100   -0.0001
   140        0.0120             nan     0.0100    0.0001
   160        0.0105             nan     0.0100    0.0001
   180        0.0092             nan     0.0100   -0.0000
   200        0.0082             nan     0.0100    0.0000

- Fold17: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold17: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0436             nan     0.0100    0.0002
     2        0.0428             nan     0.0100    0.0006
     3        0.0421             nan     0.0100    0.0008
     4        0.0413             nan     0.0100    0.0006
     5        0.0408             nan     0.0100    0.0003
     6        0.0401             nan     0.0100    0.0006
     7        0.0395             nan     0.0100    0.0004
     8        0.0391             nan     0.0100    0.0004
     9        0.0386             nan     0.0100    0.0003
    10        0.0382             nan     0.0100    0.0003
    20        0.0325             nan     0.0100    0.0004
    40        0.0246             nan     0.0100    0.0001
    60        0.0190             nan     0.0100    0.0001
    80        0.0143             nan     0.0100    0.0000
   100        0.0109             nan     0.0100    0.0000
   120        0.0086             nan     0.0100    0.0001
   140        0.0069             nan     0.0100    0.0001
   160        0.0055             nan     0.0100   -0.0000
   180        0.0044             nan     0.0100    0.0000
   200        0.0035             nan     0.0100    0.0000

- Fold17: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold17: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0435             nan     0.0100    0.0001
     2        0.0428             nan     0.0100    0.0005
     3        0.0424             nan     0.0100    0.0004
     4        0.0416             nan     0.0100    0.0007
     5        0.0410             nan     0.0100    0.0006
     6        0.0403             nan     0.0100    0.0007
     7        0.0399             nan     0.0100    0.0002
     8        0.0394             nan     0.0100    0.0003
     9        0.0387             nan     0.0100    0.0006
    10        0.0381             nan     0.0100    0.0006
    20        0.0328             nan     0.0100    0.0002
    40        0.0254             nan     0.0100    0.0004
    60        0.0195             nan     0.0100    0.0001
    80        0.0151             nan     0.0100    0.0001
   100        0.0119             nan     0.0100    0.0001
   120        0.0098             nan     0.0100    0.0001
   140        0.0079             nan     0.0100    0.0000
   160        0.0063             nan     0.0100    0.0001
   180        0.0051             nan     0.0100    0.0000
   200        0.0042             nan     0.0100    0.0000

- Fold17: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold17: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0434             nan     0.0100    0.0006
     2        0.0429             nan     0.0100    0.0003
     3        0.0422             nan     0.0100    0.0006
     4        0.0419             nan     0.0100    0.0002
     5        0.0413             nan     0.0100    0.0004
     6        0.0407             nan     0.0100    0.0006
     7        0.0403             nan     0.0100    0.0003
     8        0.0398             nan     0.0100    0.0004
     9        0.0393             nan     0.0100    0.0005
    10        0.0390             nan     0.0100    0.0000
    20        0.0346             nan     0.0100    0.0004
    40        0.0285             nan     0.0100    0.0001
    60        0.0235             nan     0.0100    0.0002
    80        0.0195             nan     0.0100    0.0002
   100        0.0166             nan     0.0100    0.0001
   120        0.0142             nan     0.0100    0.0001
   140        0.0123             nan     0.0100    0.0001
   160        0.0106             nan     0.0100    0.0000
   180        0.0093             nan     0.0100    0.0000
   200        0.0082             nan     0.0100    0.0000

- Fold17: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold17: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0432             nan     0.0100    0.0003
     2        0.0424             nan     0.0100    0.0005
     3        0.0420             nan     0.0100    0.0002
     4        0.0413             nan     0.0100    0.0005
     5        0.0407             nan     0.0100    0.0005
     6        0.0402             nan     0.0100    0.0002
     7        0.0397             nan     0.0100    0.0004
     8        0.0390             nan     0.0100    0.0007
     9        0.0385             nan     0.0100    0.0004
    10        0.0382             nan     0.0100    0.0000
    20        0.0334             nan     0.0100    0.0005
    40        0.0251             nan     0.0100    0.0003
    60        0.0187             nan     0.0100    0.0002
    80        0.0139             nan     0.0100    0.0002
   100        0.0105             nan     0.0100    0.0002
   120        0.0082             nan     0.0100    0.0000
   140        0.0064             nan     0.0100    0.0001
   160        0.0049             nan     0.0100    0.0000
   180        0.0038             nan     0.0100    0.0000
   200        0.0030             nan     0.0100    0.0000

- Fold17: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold17: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0432             nan     0.0100    0.0004
     2        0.0425             nan     0.0100    0.0007
     3        0.0418             nan     0.0100    0.0006
     4        0.0411             nan     0.0100    0.0002
     5        0.0407             nan     0.0100    0.0003
     6        0.0400             nan     0.0100    0.0004
     7        0.0395             nan     0.0100    0.0003
     8        0.0390             nan     0.0100    0.0006
     9        0.0383             nan     0.0100    0.0006
    10        0.0378             nan     0.0100    0.0005
    20        0.0332             nan     0.0100    0.0000
    40        0.0250             nan     0.0100    0.0004
    60        0.0191             nan     0.0100    0.0003
    80        0.0149             nan     0.0100    0.0001
   100        0.0118             nan     0.0100    0.0001
   120        0.0094             nan     0.0100    0.0001
   140        0.0074             nan     0.0100    0.0001
   160        0.0060             nan     0.0100   -0.0000
   180        0.0049             nan     0.0100    0.0000
   200        0.0041             nan     0.0100    0.0000

- Fold17: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold17: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0434             nan     0.0100    0.0005
     2        0.0429             nan     0.0100    0.0004
     3        0.0424             nan     0.0100    0.0005
     4        0.0420             nan     0.0100    0.0002
     5        0.0415             nan     0.0100    0.0005
     6        0.0410             nan     0.0100    0.0003
     7        0.0404             nan     0.0100    0.0005
     8        0.0400             nan     0.0100    0.0003
     9        0.0395             nan     0.0100    0.0005
    10        0.0391             nan     0.0100    0.0003
    20        0.0344             nan     0.0100    0.0005
    40        0.0279             nan     0.0100    0.0001
    60        0.0226             nan     0.0100    0.0001
    80        0.0189             nan     0.0100    0.0002
   100        0.0160             nan     0.0100    0.0001
   120        0.0138             nan     0.0100    0.0001
   140        0.0119             nan     0.0100    0.0000
   160        0.0103             nan     0.0100    0.0001
   180        0.0091             nan     0.0100    0.0000
   200        0.0081             nan     0.0100   -0.0000

- Fold17: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold17: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0410             nan     0.0500    0.0026
     2        0.0381             nan     0.0500    0.0018
     3        0.0359             nan     0.0500    0.0021
     4        0.0341             nan     0.0500    0.0017
     5        0.0325             nan     0.0500    0.0019
     6        0.0298             nan     0.0500    0.0016
     7        0.0278             nan     0.0500    0.0018
     8        0.0266             nan     0.0500    0.0013
     9        0.0252             nan     0.0500    0.0003
    10        0.0244             nan     0.0500   -0.0000
    20        0.0151             nan     0.0500    0.0000
    40        0.0064             nan     0.0500    0.0001
    60        0.0035             nan     0.0500    0.0000
    80        0.0018             nan     0.0500    0.0000
   100        0.0010             nan     0.0500   -0.0000
   120        0.0006             nan     0.0500   -0.0000
   140        0.0004             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500    0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold17: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold17: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0406             nan     0.0500    0.0025
     2        0.0378             nan     0.0500    0.0027
     3        0.0351             nan     0.0500    0.0016
     4        0.0326             nan     0.0500    0.0018
     5        0.0310             nan     0.0500    0.0010
     6        0.0289             nan     0.0500    0.0020
     7        0.0269             nan     0.0500    0.0014
     8        0.0250             nan     0.0500    0.0017
     9        0.0233             nan     0.0500    0.0010
    10        0.0215             nan     0.0500    0.0013
    20        0.0135             nan     0.0500    0.0001
    40        0.0064             nan     0.0500   -0.0000
    60        0.0032             nan     0.0500   -0.0001
    80        0.0019             nan     0.0500    0.0000
   100        0.0012             nan     0.0500   -0.0000
   120        0.0007             nan     0.0500    0.0000
   140        0.0004             nan     0.0500    0.0000
   160        0.0003             nan     0.0500    0.0000
   180        0.0002             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold17: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold17: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0414             nan     0.0500    0.0015
     2        0.0388             nan     0.0500    0.0013
     3        0.0363             nan     0.0500    0.0024
     4        0.0332             nan     0.0500    0.0022
     5        0.0311             nan     0.0500    0.0017
     6        0.0290             nan     0.0500    0.0019
     7        0.0272             nan     0.0500    0.0018
     8        0.0260             nan     0.0500    0.0014
     9        0.0248             nan     0.0500    0.0010
    10        0.0239             nan     0.0500    0.0005
    20        0.0144             nan     0.0500   -0.0002
    40        0.0078             nan     0.0500    0.0002
    60        0.0047             nan     0.0500   -0.0000
    80        0.0030             nan     0.0500   -0.0000
   100        0.0022             nan     0.0500   -0.0001
   120        0.0015             nan     0.0500   -0.0000
   140        0.0011             nan     0.0500   -0.0000
   160        0.0008             nan     0.0500   -0.0000
   180        0.0006             nan     0.0500   -0.0000
   200        0.0005             nan     0.0500    0.0000

- Fold17: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold17: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0407             nan     0.0500    0.0029
     2        0.0374             nan     0.0500    0.0033
     3        0.0348             nan     0.0500    0.0026
     4        0.0325             nan     0.0500    0.0006
     5        0.0297             nan     0.0500    0.0028
     6        0.0277             nan     0.0500    0.0017
     7        0.0263             nan     0.0500    0.0003
     8        0.0246             nan     0.0500    0.0013
     9        0.0225             nan     0.0500    0.0014
    10        0.0209             nan     0.0500    0.0012
    20        0.0115             nan     0.0500    0.0004
    40        0.0033             nan     0.0500    0.0001
    60        0.0013             nan     0.0500   -0.0000
    80        0.0007             nan     0.0500   -0.0000
   100        0.0003             nan     0.0500   -0.0000
   120        0.0002             nan     0.0500   -0.0000
   140        0.0001             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500    0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold17: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold17: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0407             nan     0.0500    0.0029
     2        0.0380             nan     0.0500    0.0025
     3        0.0355             nan     0.0500    0.0023
     4        0.0335             nan     0.0500    0.0015
     5        0.0315             nan     0.0500    0.0014
     6        0.0288             nan     0.0500    0.0015
     7        0.0264             nan     0.0500    0.0009
     8        0.0249             nan     0.0500    0.0015
     9        0.0235             nan     0.0500    0.0016
    10        0.0217             nan     0.0500    0.0011
    20        0.0114             nan     0.0500    0.0004
    40        0.0042             nan     0.0500    0.0001
    60        0.0019             nan     0.0500   -0.0000
    80        0.0009             nan     0.0500    0.0000
   100        0.0004             nan     0.0500   -0.0000
   120        0.0002             nan     0.0500    0.0000
   140        0.0001             nan     0.0500   -0.0000
   160        0.0001             nan     0.0500    0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold17: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold17: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0421             nan     0.0500    0.0007
     2        0.0400             nan     0.0500    0.0019
     3        0.0379             nan     0.0500    0.0015
     4        0.0349             nan     0.0500    0.0013
     5        0.0338             nan     0.0500    0.0004
     6        0.0317             nan     0.0500    0.0010
     7        0.0300             nan     0.0500    0.0020
     8        0.0283             nan     0.0500    0.0014
     9        0.0269             nan     0.0500    0.0016
    10        0.0262             nan     0.0500    0.0003
    20        0.0166             nan     0.0500    0.0007
    40        0.0079             nan     0.0500    0.0002
    60        0.0046             nan     0.0500    0.0001
    80        0.0030             nan     0.0500    0.0001
   100        0.0021             nan     0.0500   -0.0000
   120        0.0015             nan     0.0500   -0.0000
   140        0.0011             nan     0.0500    0.0000
   160        0.0008             nan     0.0500   -0.0000
   180        0.0006             nan     0.0500    0.0000
   200        0.0005             nan     0.0500   -0.0000

- Fold17: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold17: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0404             nan     0.0500    0.0025
     2        0.0378             nan     0.0500    0.0024
     3        0.0341             nan     0.0500    0.0019
     4        0.0322             nan     0.0500    0.0021
     5        0.0295             nan     0.0500    0.0014
     6        0.0277             nan     0.0500   -0.0001
     7        0.0250             nan     0.0500    0.0018
     8        0.0242             nan     0.0500    0.0007
     9        0.0226             nan     0.0500    0.0006
    10        0.0210             nan     0.0500    0.0020
    20        0.0114             nan     0.0500    0.0002
    40        0.0031             nan     0.0500    0.0001
    60        0.0011             nan     0.0500    0.0000
    80        0.0005             nan     0.0500    0.0000
   100        0.0002             nan     0.0500    0.0000
   120        0.0001             nan     0.0500    0.0000
   140        0.0000             nan     0.0500    0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500    0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold17: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold17: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0403             nan     0.0500    0.0031
     2        0.0374             nan     0.0500    0.0022
     3        0.0337             nan     0.0500    0.0021
     4        0.0314             nan     0.0500    0.0018
     5        0.0302             nan     0.0500    0.0011
     6        0.0284             nan     0.0500    0.0021
     7        0.0269             nan     0.0500    0.0009
     8        0.0242             nan     0.0500    0.0018
     9        0.0222             nan     0.0500    0.0016
    10        0.0201             nan     0.0500    0.0013
    20        0.0095             nan     0.0500   -0.0003
    40        0.0031             nan     0.0500    0.0002
    60        0.0013             nan     0.0500    0.0000
    80        0.0006             nan     0.0500    0.0000
   100        0.0003             nan     0.0500   -0.0000
   120        0.0002             nan     0.0500   -0.0000
   140        0.0001             nan     0.0500   -0.0000
   160        0.0001             nan     0.0500    0.0000
   180        0.0001             nan     0.0500    0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold17: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold17: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0414             nan     0.0500    0.0022
     2        0.0383             nan     0.0500    0.0027
     3        0.0363             nan     0.0500    0.0023
     4        0.0349             nan     0.0500    0.0013
     5        0.0330             nan     0.0500    0.0016
     6        0.0317             nan     0.0500    0.0004
     7        0.0297             nan     0.0500    0.0012
     8        0.0282             nan     0.0500    0.0012
     9        0.0269             nan     0.0500    0.0009
    10        0.0250             nan     0.0500    0.0015
    20        0.0157             nan     0.0500    0.0005
    40        0.0079             nan     0.0500    0.0001
    60        0.0049             nan     0.0500   -0.0002
    80        0.0032             nan     0.0500    0.0001
   100        0.0022             nan     0.0500   -0.0000
   120        0.0014             nan     0.0500   -0.0000
   140        0.0010             nan     0.0500    0.0000
   160        0.0007             nan     0.0500    0.0000
   180        0.0005             nan     0.0500    0.0000
   200        0.0004             nan     0.0500   -0.0000

- Fold17: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold17: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0381             nan     0.1000    0.0067
     2        0.0332             nan     0.1000    0.0049
     3        0.0301             nan     0.1000    0.0020
     4        0.0270             nan     0.1000    0.0028
     5        0.0239             nan     0.1000    0.0030
     6        0.0218             nan     0.1000    0.0015
     7        0.0189             nan     0.1000    0.0018
     8        0.0165             nan     0.1000    0.0017
     9        0.0152             nan     0.1000    0.0012
    10        0.0146             nan     0.1000   -0.0004
    20        0.0063             nan     0.1000    0.0006
    40        0.0017             nan     0.1000   -0.0000
    60        0.0007             nan     0.1000   -0.0000
    80        0.0003             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000    0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold17: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold17: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0390             nan     0.1000    0.0047
     2        0.0339             nan     0.1000    0.0038
     3        0.0314             nan     0.1000    0.0011
     4        0.0284             nan     0.1000    0.0037
     5        0.0258             nan     0.1000    0.0024
     6        0.0227             nan     0.1000    0.0027
     7        0.0196             nan     0.1000    0.0022
     8        0.0174             nan     0.1000    0.0016
     9        0.0153             nan     0.1000    0.0020
    10        0.0144             nan     0.1000   -0.0002
    20        0.0064             nan     0.1000    0.0002
    40        0.0022             nan     0.1000   -0.0000
    60        0.0009             nan     0.1000   -0.0000
    80        0.0004             nan     0.1000   -0.0000
   100        0.0002             nan     0.1000    0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold17: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold17: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0401             nan     0.1000    0.0017
     2        0.0364             nan     0.1000    0.0023
     3        0.0316             nan     0.1000    0.0040
     4        0.0279             nan     0.1000    0.0021
     5        0.0255             nan     0.1000   -0.0008
     6        0.0230             nan     0.1000    0.0028
     7        0.0199             nan     0.1000    0.0024
     8        0.0178             nan     0.1000    0.0014
     9        0.0169             nan     0.1000    0.0007
    10        0.0156             nan     0.1000   -0.0010
    20        0.0067             nan     0.1000    0.0004
    40        0.0026             nan     0.1000   -0.0001
    60        0.0010             nan     0.1000    0.0000
    80        0.0005             nan     0.1000   -0.0000
   100        0.0003             nan     0.1000    0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000    0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000    0.0000

- Fold17: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold17: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0381             nan     0.1000    0.0058
     2        0.0318             nan     0.1000    0.0066
     3        0.0291             nan     0.1000    0.0025
     4        0.0250             nan     0.1000    0.0027
     5        0.0209             nan     0.1000    0.0022
     6        0.0189             nan     0.1000    0.0007
     7        0.0155             nan     0.1000    0.0017
     8        0.0134             nan     0.1000    0.0013
     9        0.0117             nan     0.1000    0.0013
    10        0.0098             nan     0.1000    0.0010
    20        0.0033             nan     0.1000    0.0003
    40        0.0005             nan     0.1000   -0.0000
    60        0.0001             nan     0.1000   -0.0000
    80        0.0000             nan     0.1000    0.0000
   100        0.0000             nan     0.1000    0.0000
   120        0.0000             nan     0.1000    0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold17: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold17: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0377             nan     0.1000    0.0061
     2        0.0322             nan     0.1000    0.0043
     3        0.0281             nan     0.1000    0.0044
     4        0.0240             nan     0.1000    0.0040
     5        0.0207             nan     0.1000    0.0025
     6        0.0178             nan     0.1000    0.0025
     7        0.0158             nan     0.1000    0.0015
     8        0.0130             nan     0.1000    0.0014
     9        0.0116             nan     0.1000    0.0005
    10        0.0106             nan     0.1000    0.0011
    20        0.0040             nan     0.1000    0.0001
    40        0.0008             nan     0.1000   -0.0000
    60        0.0003             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold17: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold17: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0369             nan     0.1000    0.0054
     2        0.0317             nan     0.1000    0.0040
     3        0.0286             nan     0.1000    0.0030
     4        0.0253             nan     0.1000    0.0017
     5        0.0227             nan     0.1000    0.0025
     6        0.0203             nan     0.1000    0.0013
     7        0.0181             nan     0.1000    0.0018
     8        0.0162             nan     0.1000    0.0017
     9        0.0150             nan     0.1000    0.0008
    10        0.0142             nan     0.1000    0.0006
    20        0.0071             nan     0.1000    0.0005
    40        0.0029             nan     0.1000   -0.0001
    60        0.0012             nan     0.1000    0.0001
    80        0.0006             nan     0.1000   -0.0000
   100        0.0003             nan     0.1000   -0.0000
   120        0.0002             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000    0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold17: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold17: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0362             nan     0.1000    0.0056
     2        0.0302             nan     0.1000    0.0042
     3        0.0276             nan     0.1000   -0.0002
     4        0.0247             nan     0.1000    0.0002
     5        0.0223             nan     0.1000    0.0019
     6        0.0192             nan     0.1000    0.0023
     7        0.0177             nan     0.1000   -0.0004
     8        0.0149             nan     0.1000    0.0024
     9        0.0136             nan     0.1000    0.0004
    10        0.0115             nan     0.1000    0.0019
    20        0.0026             nan     0.1000    0.0003
    40        0.0005             nan     0.1000    0.0000
    60        0.0001             nan     0.1000    0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000    0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000    0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold17: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold17: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0392             nan     0.1000    0.0046
     2        0.0351             nan     0.1000    0.0028
     3        0.0309             nan     0.1000    0.0028
     4        0.0281             nan     0.1000    0.0036
     5        0.0246             nan     0.1000    0.0026
     6        0.0220             nan     0.1000    0.0014
     7        0.0212             nan     0.1000    0.0000
     8        0.0185             nan     0.1000    0.0012
     9        0.0157             nan     0.1000    0.0018
    10        0.0131             nan     0.1000    0.0004
    20        0.0056             nan     0.1000   -0.0000
    40        0.0017             nan     0.1000    0.0001
    60        0.0004             nan     0.1000   -0.0000
    80        0.0002             nan     0.1000    0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000    0.0000

- Fold17: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold17: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0412             nan     0.1000    0.0017
     2        0.0354             nan     0.1000    0.0039
     3        0.0326             nan     0.1000    0.0012
     4        0.0289             nan     0.1000    0.0016
     5        0.0266             nan     0.1000    0.0029
     6        0.0243             nan     0.1000   -0.0005
     7        0.0234             nan     0.1000   -0.0007
     8        0.0222             nan     0.1000    0.0005
     9        0.0199             nan     0.1000    0.0017
    10        0.0177             nan     0.1000    0.0004
    20        0.0086             nan     0.1000    0.0007
    40        0.0030             nan     0.1000   -0.0002
    60        0.0016             nan     0.1000   -0.0001
    80        0.0009             nan     0.1000    0.0000
   100        0.0005             nan     0.1000   -0.0000
   120        0.0002             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000    0.0000

- Fold17: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold18: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0426             nan     0.0100    0.0007
     2        0.0422             nan     0.0100    0.0004
     3        0.0415             nan     0.0100    0.0005
     4        0.0412             nan     0.0100    0.0000
     5        0.0408             nan     0.0100    0.0005
     6        0.0403             nan     0.0100    0.0005
     7        0.0399             nan     0.0100    0.0001
     8        0.0393             nan     0.0100    0.0004
     9        0.0388             nan     0.0100    0.0003
    10        0.0384             nan     0.0100    0.0003
    20        0.0342             nan     0.0100    0.0004
    40        0.0270             nan     0.0100    0.0002
    60        0.0218             nan     0.0100    0.0000
    80        0.0175             nan     0.0100    0.0002
   100        0.0142             nan     0.0100    0.0001
   120        0.0117             nan     0.0100    0.0001
   140        0.0095             nan     0.0100    0.0001
   160        0.0079             nan     0.0100    0.0000
   180        0.0068             nan     0.0100    0.0000
   200        0.0059             nan     0.0100    0.0000

- Fold18: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold18: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0428             nan     0.0100    0.0003
     2        0.0424             nan     0.0100    0.0004
     3        0.0418             nan     0.0100    0.0005
     4        0.0412             nan     0.0100    0.0003
     5        0.0406             nan     0.0100    0.0005
     6        0.0402             nan     0.0100    0.0005
     7        0.0398             nan     0.0100    0.0003
     8        0.0393             nan     0.0100    0.0004
     9        0.0388             nan     0.0100    0.0004
    10        0.0382             nan     0.0100    0.0005
    20        0.0345             nan     0.0100    0.0003
    40        0.0274             nan     0.0100    0.0001
    60        0.0225             nan     0.0100    0.0002
    80        0.0184             nan     0.0100    0.0001
   100        0.0151             nan     0.0100    0.0002
   120        0.0126             nan     0.0100    0.0000
   140        0.0102             nan     0.0100    0.0001
   160        0.0087             nan     0.0100    0.0000
   180        0.0073             nan     0.0100   -0.0000
   200        0.0061             nan     0.0100    0.0000

- Fold18: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold18: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0430             nan     0.0100    0.0001
     2        0.0424             nan     0.0100    0.0006
     3        0.0418             nan     0.0100    0.0004
     4        0.0415             nan     0.0100    0.0004
     5        0.0410             nan     0.0100    0.0002
     6        0.0404             nan     0.0100    0.0004
     7        0.0404             nan     0.0100   -0.0004
     8        0.0402             nan     0.0100    0.0001
     9        0.0397             nan     0.0100    0.0005
    10        0.0392             nan     0.0100    0.0005
    20        0.0348             nan     0.0100    0.0004
    40        0.0280             nan     0.0100   -0.0001
    60        0.0230             nan     0.0100    0.0000
    80        0.0189             nan     0.0100    0.0002
   100        0.0158             nan     0.0100    0.0001
   120        0.0134             nan     0.0100    0.0001
   140        0.0116             nan     0.0100    0.0000
   160        0.0101             nan     0.0100    0.0001
   180        0.0091             nan     0.0100    0.0000
   200        0.0084             nan     0.0100   -0.0001

- Fold18: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold18: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0427             nan     0.0100    0.0005
     2        0.0421             nan     0.0100    0.0004
     3        0.0417             nan     0.0100    0.0001
     4        0.0412             nan     0.0100    0.0003
     5        0.0406             nan     0.0100    0.0004
     6        0.0400             nan     0.0100    0.0004
     7        0.0392             nan     0.0100    0.0008
     8        0.0387             nan     0.0100    0.0002
     9        0.0381             nan     0.0100    0.0005
    10        0.0377             nan     0.0100    0.0003
    20        0.0324             nan     0.0100    0.0002
    40        0.0255             nan     0.0100    0.0002
    60        0.0197             nan     0.0100    0.0003
    80        0.0158             nan     0.0100    0.0001
   100        0.0121             nan     0.0100    0.0001
   120        0.0098             nan     0.0100    0.0000
   140        0.0079             nan     0.0100    0.0001
   160        0.0065             nan     0.0100    0.0000
   180        0.0052             nan     0.0100    0.0001
   200        0.0042             nan     0.0100    0.0000

- Fold18: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold18: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0428             nan     0.0100    0.0004
     2        0.0422             nan     0.0100    0.0005
     3        0.0415             nan     0.0100    0.0005
     4        0.0409             nan     0.0100    0.0005
     5        0.0402             nan     0.0100    0.0005
     6        0.0395             nan     0.0100    0.0005
     7        0.0390             nan     0.0100    0.0005
     8        0.0386             nan     0.0100    0.0004
     9        0.0381             nan     0.0100    0.0001
    10        0.0377             nan     0.0100    0.0004
    20        0.0322             nan     0.0100    0.0005
    40        0.0246             nan     0.0100    0.0003
    60        0.0186             nan     0.0100    0.0002
    80        0.0147             nan     0.0100    0.0002
   100        0.0113             nan     0.0100    0.0001
   120        0.0089             nan     0.0100    0.0001
   140        0.0071             nan     0.0100    0.0001
   160        0.0057             nan     0.0100    0.0000
   180        0.0048             nan     0.0100    0.0000
   200        0.0040             nan     0.0100    0.0000

- Fold18: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold18: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0427             nan     0.0100    0.0006
     2        0.0423             nan     0.0100    0.0004
     3        0.0418             nan     0.0100    0.0005
     4        0.0412             nan     0.0100    0.0004
     5        0.0408             nan     0.0100    0.0004
     6        0.0407             nan     0.0100   -0.0002
     7        0.0403             nan     0.0100    0.0003
     8        0.0399             nan     0.0100    0.0003
     9        0.0395             nan     0.0100    0.0003
    10        0.0390             nan     0.0100    0.0005
    20        0.0349             nan     0.0100    0.0005
    40        0.0279             nan     0.0100    0.0003
    60        0.0232             nan     0.0100    0.0000
    80        0.0196             nan     0.0100   -0.0000
   100        0.0164             nan     0.0100    0.0001
   120        0.0140             nan     0.0100    0.0001
   140        0.0123             nan     0.0100    0.0000
   160        0.0107             nan     0.0100   -0.0000
   180        0.0097             nan     0.0100   -0.0001
   200        0.0087             nan     0.0100    0.0000

- Fold18: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold18: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0428             nan     0.0100    0.0002
     2        0.0422             nan     0.0100    0.0002
     3        0.0417             nan     0.0100    0.0004
     4        0.0411             nan     0.0100    0.0002
     5        0.0404             nan     0.0100    0.0005
     6        0.0398             nan     0.0100    0.0004
     7        0.0392             nan     0.0100    0.0004
     8        0.0386             nan     0.0100    0.0005
     9        0.0381             nan     0.0100    0.0002
    10        0.0375             nan     0.0100    0.0004
    20        0.0322             nan     0.0100    0.0004
    40        0.0238             nan     0.0100    0.0001
    60        0.0178             nan     0.0100    0.0000
    80        0.0133             nan     0.0100    0.0002
   100        0.0103             nan     0.0100    0.0002
   120        0.0081             nan     0.0100    0.0001
   140        0.0063             nan     0.0100    0.0000
   160        0.0051             nan     0.0100    0.0000
   180        0.0040             nan     0.0100    0.0000
   200        0.0032             nan     0.0100    0.0000

- Fold18: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold18: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0429             nan     0.0100    0.0004
     2        0.0423             nan     0.0100    0.0002
     3        0.0418             nan     0.0100    0.0003
     4        0.0413             nan     0.0100    0.0003
     5        0.0406             nan     0.0100    0.0007
     6        0.0399             nan     0.0100    0.0006
     7        0.0395             nan     0.0100    0.0004
     8        0.0390             nan     0.0100    0.0006
     9        0.0383             nan     0.0100    0.0004
    10        0.0377             nan     0.0100    0.0006
    20        0.0326             nan     0.0100    0.0004
    40        0.0249             nan     0.0100    0.0002
    60        0.0200             nan     0.0100    0.0002
    80        0.0151             nan     0.0100    0.0001
   100        0.0119             nan     0.0100    0.0001
   120        0.0096             nan     0.0100    0.0001
   140        0.0076             nan     0.0100    0.0000
   160        0.0061             nan     0.0100   -0.0000
   180        0.0050             nan     0.0100    0.0000
   200        0.0041             nan     0.0100   -0.0000

- Fold18: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold18: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0430             nan     0.0100    0.0004
     2        0.0425             nan     0.0100    0.0005
     3        0.0420             nan     0.0100    0.0003
     4        0.0416             nan     0.0100    0.0004
     5        0.0410             nan     0.0100    0.0006
     6        0.0404             nan     0.0100    0.0006
     7        0.0398             nan     0.0100    0.0005
     8        0.0393             nan     0.0100    0.0005
     9        0.0387             nan     0.0100    0.0005
    10        0.0382             nan     0.0100    0.0001
    20        0.0348             nan     0.0100    0.0001
    40        0.0285             nan     0.0100    0.0003
    60        0.0233             nan     0.0100    0.0002
    80        0.0194             nan     0.0100    0.0001
   100        0.0164             nan     0.0100   -0.0000
   120        0.0136             nan     0.0100    0.0001
   140        0.0116             nan     0.0100    0.0000
   160        0.0102             nan     0.0100    0.0000
   180        0.0090             nan     0.0100    0.0000
   200        0.0080             nan     0.0100    0.0000

- Fold18: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold18: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0408             nan     0.0500    0.0028
     2        0.0380             nan     0.0500    0.0008
     3        0.0367             nan     0.0500    0.0002
     4        0.0343             nan     0.0500    0.0016
     5        0.0327             nan     0.0500    0.0015
     6        0.0302             nan     0.0500    0.0016
     7        0.0285             nan     0.0500    0.0017
     8        0.0268             nan     0.0500    0.0012
     9        0.0247             nan     0.0500    0.0018
    10        0.0240             nan     0.0500    0.0006
    20        0.0135             nan     0.0500    0.0007
    40        0.0055             nan     0.0500    0.0002
    60        0.0027             nan     0.0500    0.0001
    80        0.0014             nan     0.0500    0.0000
   100        0.0008             nan     0.0500    0.0000
   120        0.0005             nan     0.0500    0.0000
   140        0.0003             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500    0.0000

- Fold18: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold18: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0413             nan     0.0500    0.0013
     2        0.0394             nan     0.0500    0.0016
     3        0.0379             nan     0.0500    0.0003
     4        0.0360             nan     0.0500    0.0012
     5        0.0336             nan     0.0500    0.0024
     6        0.0310             nan     0.0500    0.0019
     7        0.0291             nan     0.0500    0.0011
     8        0.0277             nan     0.0500    0.0006
     9        0.0260             nan     0.0500    0.0015
    10        0.0249             nan     0.0500    0.0009
    20        0.0144             nan     0.0500    0.0008
    40        0.0061             nan     0.0500    0.0001
    60        0.0034             nan     0.0500   -0.0000
    80        0.0022             nan     0.0500    0.0000
   100        0.0014             nan     0.0500   -0.0001
   120        0.0009             nan     0.0500   -0.0000
   140        0.0006             nan     0.0500   -0.0000
   160        0.0004             nan     0.0500   -0.0000
   180        0.0002             nan     0.0500    0.0000
   200        0.0002             nan     0.0500   -0.0000

- Fold18: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold18: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0408             nan     0.0500    0.0026
     2        0.0378             nan     0.0500    0.0026
     3        0.0359             nan     0.0500    0.0012
     4        0.0334             nan     0.0500    0.0018
     5        0.0323             nan     0.0500    0.0005
     6        0.0309             nan     0.0500    0.0011
     7        0.0292             nan     0.0500    0.0017
     8        0.0282             nan     0.0500    0.0007
     9        0.0267             nan     0.0500    0.0016
    10        0.0252             nan     0.0500    0.0007
    20        0.0169             nan     0.0500    0.0002
    40        0.0096             nan     0.0500   -0.0001
    60        0.0067             nan     0.0500    0.0001
    80        0.0045             nan     0.0500    0.0001
   100        0.0034             nan     0.0500   -0.0000
   120        0.0022             nan     0.0500    0.0000
   140        0.0015             nan     0.0500    0.0000
   160        0.0010             nan     0.0500   -0.0000
   180        0.0008             nan     0.0500   -0.0000
   200        0.0006             nan     0.0500   -0.0000

- Fold18: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold18: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0417             nan     0.0500    0.0007
     2        0.0404             nan     0.0500    0.0013
     3        0.0375             nan     0.0500    0.0027
     4        0.0343             nan     0.0500    0.0026
     5        0.0309             nan     0.0500    0.0030
     6        0.0286             nan     0.0500    0.0017
     7        0.0261             nan     0.0500    0.0020
     8        0.0245             nan     0.0500    0.0019
     9        0.0228             nan     0.0500    0.0013
    10        0.0212             nan     0.0500    0.0019
    20        0.0119             nan     0.0500    0.0003
    40        0.0038             nan     0.0500    0.0001
    60        0.0015             nan     0.0500   -0.0000
    80        0.0007             nan     0.0500   -0.0000
   100        0.0003             nan     0.0500    0.0000
   120        0.0001             nan     0.0500    0.0000
   140        0.0001             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold18: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold18: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0397             nan     0.0500    0.0031
     2        0.0366             nan     0.0500    0.0028
     3        0.0341             nan     0.0500    0.0021
     4        0.0317             nan     0.0500    0.0020
     5        0.0297             nan     0.0500    0.0020
     6        0.0274             nan     0.0500    0.0015
     7        0.0253             nan     0.0500    0.0014
     8        0.0236             nan     0.0500    0.0004
     9        0.0227             nan     0.0500    0.0000
    10        0.0217             nan     0.0500    0.0007
    20        0.0128             nan     0.0500    0.0001
    40        0.0050             nan     0.0500    0.0002
    60        0.0022             nan     0.0500   -0.0000
    80        0.0010             nan     0.0500    0.0000
   100        0.0006             nan     0.0500   -0.0000
   120        0.0004             nan     0.0500   -0.0000
   140        0.0002             nan     0.0500   -0.0000
   160        0.0001             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold18: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold18: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0405             nan     0.0500    0.0011
     2        0.0389             nan     0.0500    0.0016
     3        0.0360             nan     0.0500    0.0020
     4        0.0339             nan     0.0500    0.0008
     5        0.0315             nan     0.0500    0.0020
     6        0.0302             nan     0.0500   -0.0005
     7        0.0289             nan     0.0500    0.0011
     8        0.0271             nan     0.0500    0.0016
     9        0.0261             nan     0.0500    0.0008
    10        0.0250             nan     0.0500    0.0008
    20        0.0153             nan     0.0500    0.0006
    40        0.0082             nan     0.0500    0.0000
    60        0.0053             nan     0.0500   -0.0001
    80        0.0034             nan     0.0500   -0.0000
   100        0.0022             nan     0.0500    0.0000
   120        0.0015             nan     0.0500    0.0000
   140        0.0010             nan     0.0500    0.0000
   160        0.0008             nan     0.0500   -0.0000
   180        0.0006             nan     0.0500   -0.0000
   200        0.0004             nan     0.0500   -0.0000

- Fold18: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold18: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0398             nan     0.0500    0.0007
     2        0.0389             nan     0.0500    0.0002
     3        0.0365             nan     0.0500    0.0022
     4        0.0335             nan     0.0500    0.0023
     5        0.0309             nan     0.0500    0.0014
     6        0.0295             nan     0.0500    0.0013
     7        0.0269             nan     0.0500    0.0020
     8        0.0248             nan     0.0500    0.0020
     9        0.0235             nan     0.0500    0.0011
    10        0.0218             nan     0.0500    0.0005
    20        0.0102             nan     0.0500    0.0007
    40        0.0028             nan     0.0500    0.0001
    60        0.0010             nan     0.0500    0.0000
    80        0.0004             nan     0.0500   -0.0000
   100        0.0002             nan     0.0500    0.0000
   120        0.0001             nan     0.0500    0.0000
   140        0.0000             nan     0.0500    0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold18: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold18: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0403             nan     0.0500    0.0016
     2        0.0385             nan     0.0500    0.0010
     3        0.0358             nan     0.0500    0.0021
     4        0.0326             nan     0.0500    0.0014
     5        0.0302             nan     0.0500    0.0013
     6        0.0279             nan     0.0500    0.0020
     7        0.0258             nan     0.0500    0.0016
     8        0.0239             nan     0.0500    0.0012
     9        0.0224             nan     0.0500    0.0010
    10        0.0205             nan     0.0500    0.0017
    20        0.0113             nan     0.0500    0.0003
    40        0.0044             nan     0.0500    0.0001
    60        0.0021             nan     0.0500   -0.0000
    80        0.0014             nan     0.0500   -0.0000
   100        0.0009             nan     0.0500    0.0000
   120        0.0006             nan     0.0500   -0.0000
   140        0.0005             nan     0.0500   -0.0000
   160        0.0003             nan     0.0500   -0.0000
   180        0.0002             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500    0.0000

- Fold18: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold18: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0405             nan     0.0500    0.0025
     2        0.0377             nan     0.0500    0.0023
     3        0.0370             nan     0.0500   -0.0008
     4        0.0348             nan     0.0500    0.0023
     5        0.0327             nan     0.0500    0.0021
     6        0.0306             nan     0.0500    0.0017
     7        0.0296             nan     0.0500    0.0004
     8        0.0275             nan     0.0500    0.0012
     9        0.0259             nan     0.0500    0.0013
    10        0.0247             nan     0.0500    0.0010
    20        0.0153             nan     0.0500    0.0007
    40        0.0088             nan     0.0500   -0.0000
    60        0.0051             nan     0.0500    0.0001
    80        0.0036             nan     0.0500    0.0000
   100        0.0026             nan     0.0500    0.0000
   120        0.0019             nan     0.0500   -0.0001
   140        0.0013             nan     0.0500   -0.0000
   160        0.0009             nan     0.0500   -0.0000
   180        0.0006             nan     0.0500    0.0000
   200        0.0005             nan     0.0500   -0.0000

- Fold18: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold18: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0379             nan     0.1000    0.0043
     2        0.0335             nan     0.1000    0.0034
     3        0.0301             nan     0.1000    0.0034
     4        0.0275             nan     0.1000    0.0026
     5        0.0236             nan     0.1000    0.0027
     6        0.0204             nan     0.1000    0.0027
     7        0.0180             nan     0.1000    0.0019
     8        0.0171             nan     0.1000    0.0001
     9        0.0152             nan     0.1000    0.0017
    10        0.0139             nan     0.1000    0.0013
    20        0.0059             nan     0.1000    0.0003
    40        0.0020             nan     0.1000   -0.0001
    60        0.0008             nan     0.1000   -0.0000
    80        0.0003             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000    0.0000
   120        0.0001             nan     0.1000    0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold18: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold18: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0409             nan     0.1000    0.0017
     2        0.0377             nan     0.1000    0.0026
     3        0.0321             nan     0.1000    0.0045
     4        0.0271             nan     0.1000    0.0048
     5        0.0248             nan     0.1000    0.0021
     6        0.0209             nan     0.1000    0.0018
     7        0.0189             nan     0.1000    0.0005
     8        0.0172             nan     0.1000    0.0004
     9        0.0152             nan     0.1000    0.0016
    10        0.0137             nan     0.1000    0.0013
    20        0.0065             nan     0.1000    0.0005
    40        0.0023             nan     0.1000   -0.0001
    60        0.0008             nan     0.1000   -0.0000
    80        0.0003             nan     0.1000   -0.0000
   100        0.0002             nan     0.1000   -0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000    0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold18: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold18: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0413             nan     0.1000   -0.0001
     2        0.0366             nan     0.1000    0.0046
     3        0.0344             nan     0.1000    0.0014
     4        0.0298             nan     0.1000    0.0041
     5        0.0265             nan     0.1000    0.0028
     6        0.0235             nan     0.1000    0.0026
     7        0.0215             nan     0.1000    0.0016
     8        0.0200             nan     0.1000    0.0015
     9        0.0180             nan     0.1000    0.0019
    10        0.0171             nan     0.1000    0.0006
    20        0.0085             nan     0.1000   -0.0000
    40        0.0033             nan     0.1000    0.0001
    60        0.0017             nan     0.1000    0.0000
    80        0.0010             nan     0.1000   -0.0000
   100        0.0006             nan     0.1000   -0.0000
   120        0.0004             nan     0.1000   -0.0000
   140        0.0003             nan     0.1000    0.0000
   160        0.0002             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold18: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold18: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0385             nan     0.1000    0.0039
     2        0.0343             nan     0.1000    0.0028
     3        0.0315             nan     0.1000    0.0027
     4        0.0266             nan     0.1000    0.0034
     5        0.0231             nan     0.1000    0.0038
     6        0.0199             nan     0.1000    0.0023
     7        0.0166             nan     0.1000    0.0015
     8        0.0138             nan     0.1000    0.0015
     9        0.0117             nan     0.1000    0.0022
    10        0.0101             nan     0.1000    0.0014
    20        0.0030             nan     0.1000    0.0001
    40        0.0006             nan     0.1000   -0.0000
    60        0.0002             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold18: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold18: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0371             nan     0.1000    0.0034
     2        0.0333             nan     0.1000    0.0031
     3        0.0289             nan     0.1000    0.0034
     4        0.0248             nan     0.1000    0.0035
     5        0.0237             nan     0.1000   -0.0001
     6        0.0209             nan     0.1000    0.0010
     7        0.0182             nan     0.1000    0.0018
     8        0.0165             nan     0.1000    0.0008
     9        0.0144             nan     0.1000    0.0016
    10        0.0127             nan     0.1000    0.0008
    20        0.0050             nan     0.1000    0.0002
    40        0.0009             nan     0.1000   -0.0001
    60        0.0003             nan     0.1000    0.0000
    80        0.0001             nan     0.1000    0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000    0.0000
   160        0.0000             nan     0.1000    0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold18: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold18: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0385             nan     0.1000    0.0045
     2        0.0342             nan     0.1000    0.0029
     3        0.0299             nan     0.1000    0.0014
     4        0.0267             nan     0.1000    0.0018
     5        0.0238             nan     0.1000    0.0030
     6        0.0217             nan     0.1000    0.0004
     7        0.0197             nan     0.1000   -0.0001
     8        0.0170             nan     0.1000    0.0018
     9        0.0162             nan     0.1000   -0.0002
    10        0.0157             nan     0.1000    0.0001
    20        0.0090             nan     0.1000    0.0000
    40        0.0041             nan     0.1000   -0.0002
    60        0.0020             nan     0.1000   -0.0000
    80        0.0011             nan     0.1000   -0.0000
   100        0.0007             nan     0.1000    0.0000
   120        0.0005             nan     0.1000    0.0000
   140        0.0003             nan     0.1000   -0.0000
   160        0.0002             nan     0.1000    0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold18: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold18: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0370             nan     0.1000    0.0047
     2        0.0318             nan     0.1000    0.0037
     3        0.0262             nan     0.1000    0.0036
     4        0.0215             nan     0.1000    0.0036
     5        0.0185             nan     0.1000    0.0004
     6        0.0162             nan     0.1000    0.0020
     7        0.0135             nan     0.1000    0.0017
     8        0.0111             nan     0.1000    0.0021
     9        0.0092             nan     0.1000    0.0008
    10        0.0084             nan     0.1000    0.0005
    20        0.0028             nan     0.1000   -0.0000
    40        0.0007             nan     0.1000   -0.0000
    60        0.0002             nan     0.1000    0.0000
    80        0.0000             nan     0.1000    0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold18: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold18: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0381             nan     0.1000    0.0047
     2        0.0340             nan     0.1000    0.0045
     3        0.0286             nan     0.1000    0.0019
     4        0.0251             nan     0.1000    0.0032
     5        0.0228             nan     0.1000    0.0018
     6        0.0210             nan     0.1000    0.0010
     7        0.0183             nan     0.1000    0.0025
     8        0.0161             nan     0.1000    0.0017
     9        0.0143             nan     0.1000    0.0017
    10        0.0127             nan     0.1000    0.0008
    20        0.0045             nan     0.1000    0.0004
    40        0.0009             nan     0.1000   -0.0000
    60        0.0003             nan     0.1000    0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000    0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000    0.0000

- Fold18: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold18: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0376             nan     0.1000    0.0057
     2        0.0320             nan     0.1000    0.0033
     3        0.0283             nan     0.1000    0.0037
     4        0.0255             nan     0.1000    0.0029
     5        0.0232             nan     0.1000    0.0001
     6        0.0212             nan     0.1000    0.0016
     7        0.0201             nan     0.1000   -0.0003
     8        0.0181             nan     0.1000    0.0000
     9        0.0162             nan     0.1000    0.0011
    10        0.0156             nan     0.1000   -0.0000
    20        0.0099             nan     0.1000    0.0002
    40        0.0039             nan     0.1000    0.0000
    60        0.0021             nan     0.1000   -0.0000
    80        0.0015             nan     0.1000   -0.0000
   100        0.0010             nan     0.1000   -0.0000
   120        0.0006             nan     0.1000   -0.0000
   140        0.0004             nan     0.1000   -0.0000
   160        0.0003             nan     0.1000   -0.0000
   180        0.0002             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold18: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold19: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0429             nan     0.0100   -0.0002
     2        0.0424             nan     0.0100    0.0006
     3        0.0417             nan     0.0100    0.0005
     4        0.0412             nan     0.0100    0.0005
     5        0.0408             nan     0.0100    0.0002
     6        0.0402             nan     0.0100    0.0005
     7        0.0397             nan     0.0100    0.0006
     8        0.0392             nan     0.0100    0.0000
     9        0.0386             nan     0.0100    0.0003
    10        0.0383             nan     0.0100    0.0002
    20        0.0339             nan     0.0100    0.0001
    40        0.0270             nan     0.0100    0.0003
    60        0.0226             nan     0.0100   -0.0000
    80        0.0182             nan     0.0100    0.0000
   100        0.0146             nan     0.0100    0.0001
   120        0.0119             nan     0.0100    0.0001
   140        0.0099             nan     0.0100    0.0001
   160        0.0083             nan     0.0100    0.0001
   180        0.0073             nan     0.0100   -0.0000
   200        0.0062             nan     0.0100    0.0000

- Fold19: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold19: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0426             nan     0.0100    0.0003
     2        0.0420             nan     0.0100    0.0002
     3        0.0415             nan     0.0100    0.0002
     4        0.0410             nan     0.0100    0.0005
     5        0.0406             nan     0.0100    0.0005
     6        0.0401             nan     0.0100    0.0003
     7        0.0397             nan     0.0100    0.0004
     8        0.0393             nan     0.0100    0.0003
     9        0.0392             nan     0.0100   -0.0001
    10        0.0388             nan     0.0100    0.0002
    20        0.0345             nan     0.0100    0.0004
    40        0.0272             nan     0.0100   -0.0002
    60        0.0218             nan     0.0100    0.0001
    80        0.0180             nan     0.0100    0.0001
   100        0.0150             nan     0.0100    0.0001
   120        0.0123             nan     0.0100    0.0001
   140        0.0103             nan     0.0100    0.0001
   160        0.0089             nan     0.0100    0.0001
   180        0.0075             nan     0.0100    0.0000
   200        0.0065             nan     0.0100    0.0000

- Fold19: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold19: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0426             nan     0.0100    0.0004
     2        0.0420             nan     0.0100    0.0005
     3        0.0415             nan     0.0100    0.0006
     4        0.0410             nan     0.0100    0.0005
     5        0.0406             nan     0.0100    0.0001
     6        0.0401             nan     0.0100    0.0001
     7        0.0397             nan     0.0100    0.0004
     8        0.0390             nan     0.0100    0.0005
     9        0.0386             nan     0.0100    0.0004
    10        0.0381             nan     0.0100    0.0005
    20        0.0340             nan     0.0100    0.0003
    40        0.0275             nan     0.0100   -0.0000
    60        0.0223             nan     0.0100    0.0002
    80        0.0184             nan     0.0100    0.0002
   100        0.0154             nan     0.0100    0.0001
   120        0.0131             nan     0.0100    0.0001
   140        0.0113             nan     0.0100    0.0001
   160        0.0099             nan     0.0100    0.0000
   180        0.0086             nan     0.0100    0.0001
   200        0.0077             nan     0.0100    0.0000

- Fold19: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold19: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0424             nan     0.0100    0.0006
     2        0.0418             nan     0.0100    0.0004
     3        0.0411             nan     0.0100    0.0006
     4        0.0403             nan     0.0100    0.0008
     5        0.0396             nan     0.0100    0.0005
     6        0.0390             nan     0.0100    0.0003
     7        0.0384             nan     0.0100    0.0008
     8        0.0377             nan     0.0100    0.0005
     9        0.0373             nan     0.0100    0.0002
    10        0.0368             nan     0.0100    0.0005
    20        0.0324             nan     0.0100    0.0002
    40        0.0247             nan     0.0100    0.0002
    60        0.0193             nan     0.0100    0.0001
    80        0.0153             nan     0.0100   -0.0001
   100        0.0118             nan     0.0100    0.0001
   120        0.0091             nan     0.0100    0.0001
   140        0.0073             nan     0.0100    0.0000
   160        0.0060             nan     0.0100    0.0000
   180        0.0048             nan     0.0100    0.0000
   200        0.0038             nan     0.0100    0.0000

- Fold19: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold19: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0427             nan     0.0100    0.0001
     2        0.0424             nan     0.0100    0.0005
     3        0.0419             nan     0.0100    0.0006
     4        0.0412             nan     0.0100    0.0006
     5        0.0406             nan     0.0100    0.0006
     6        0.0399             nan     0.0100    0.0004
     7        0.0393             nan     0.0100    0.0004
     8        0.0389             nan     0.0100    0.0003
     9        0.0383             nan     0.0100    0.0006
    10        0.0377             nan     0.0100    0.0006
    20        0.0329             nan     0.0100   -0.0001
    40        0.0255             nan     0.0100    0.0003
    60        0.0196             nan     0.0100    0.0003
    80        0.0154             nan     0.0100    0.0002
   100        0.0121             nan     0.0100    0.0001
   120        0.0096             nan     0.0100    0.0001
   140        0.0081             nan     0.0100    0.0001
   160        0.0067             nan     0.0100    0.0000
   180        0.0054             nan     0.0100    0.0000
   200        0.0044             nan     0.0100    0.0000

- Fold19: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold19: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0425             nan     0.0100    0.0005
     2        0.0421             nan     0.0100    0.0004
     3        0.0415             nan     0.0100    0.0005
     4        0.0410             nan     0.0100    0.0005
     5        0.0405             nan     0.0100    0.0004
     6        0.0401             nan     0.0100    0.0002
     7        0.0395             nan     0.0100    0.0005
     8        0.0389             nan     0.0100    0.0004
     9        0.0387             nan     0.0100    0.0000
    10        0.0383             nan     0.0100    0.0004
    20        0.0346             nan     0.0100    0.0002
    40        0.0280             nan     0.0100    0.0003
    60        0.0228             nan     0.0100    0.0002
    80        0.0190             nan     0.0100    0.0002
   100        0.0162             nan     0.0100    0.0001
   120        0.0136             nan     0.0100   -0.0000
   140        0.0118             nan     0.0100    0.0000
   160        0.0100             nan     0.0100    0.0000
   180        0.0090             nan     0.0100    0.0000
   200        0.0080             nan     0.0100    0.0000

- Fold19: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold19: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0425             nan     0.0100    0.0004
     2        0.0417             nan     0.0100    0.0005
     3        0.0410             nan     0.0100    0.0002
     4        0.0403             nan     0.0100    0.0007
     5        0.0398             nan     0.0100    0.0005
     6        0.0390             nan     0.0100    0.0006
     7        0.0384             nan     0.0100    0.0005
     8        0.0381             nan     0.0100    0.0003
     9        0.0378             nan     0.0100   -0.0001
    10        0.0371             nan     0.0100    0.0005
    20        0.0323             nan     0.0100    0.0002
    40        0.0236             nan     0.0100    0.0001
    60        0.0181             nan     0.0100    0.0001
    80        0.0136             nan     0.0100    0.0001
   100        0.0103             nan     0.0100    0.0002
   120        0.0079             nan     0.0100    0.0001
   140        0.0063             nan     0.0100    0.0001
   160        0.0051             nan     0.0100    0.0000
   180        0.0040             nan     0.0100   -0.0000
   200        0.0031             nan     0.0100    0.0000

- Fold19: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold19: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0423             nan     0.0100    0.0007
     2        0.0418             nan     0.0100    0.0005
     3        0.0413             nan     0.0100    0.0005
     4        0.0408             nan     0.0100    0.0004
     5        0.0400             nan     0.0100    0.0008
     6        0.0393             nan     0.0100    0.0006
     7        0.0388             nan     0.0100    0.0002
     8        0.0381             nan     0.0100    0.0005
     9        0.0375             nan     0.0100    0.0006
    10        0.0369             nan     0.0100    0.0006
    20        0.0322             nan     0.0100    0.0001
    40        0.0254             nan     0.0100    0.0002
    60        0.0196             nan     0.0100    0.0002
    80        0.0155             nan     0.0100    0.0002
   100        0.0125             nan     0.0100    0.0000
   120        0.0103             nan     0.0100    0.0001
   140        0.0083             nan     0.0100    0.0000
   160        0.0068             nan     0.0100    0.0001
   180        0.0057             nan     0.0100    0.0000
   200        0.0048             nan     0.0100    0.0000

- Fold19: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold19: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0425             nan     0.0100    0.0005
     2        0.0418             nan     0.0100    0.0006
     3        0.0414             nan     0.0100    0.0002
     4        0.0409             nan     0.0100    0.0004
     5        0.0403             nan     0.0100    0.0003
     6        0.0398             nan     0.0100    0.0005
     7        0.0392             nan     0.0100    0.0004
     8        0.0388             nan     0.0100    0.0003
     9        0.0384             nan     0.0100    0.0004
    10        0.0381             nan     0.0100    0.0001
    20        0.0337             nan     0.0100    0.0001
    40        0.0268             nan     0.0100    0.0003
    60        0.0220             nan     0.0100    0.0002
    80        0.0182             nan     0.0100   -0.0001
   100        0.0155             nan     0.0100    0.0000
   120        0.0133             nan     0.0100   -0.0001
   140        0.0114             nan     0.0100    0.0000
   160        0.0099             nan     0.0100    0.0000
   180        0.0089             nan     0.0100   -0.0000
   200        0.0079             nan     0.0100    0.0000

- Fold19: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold19: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0409             nan     0.0500    0.0022
     2        0.0390             nan     0.0500    0.0013
     3        0.0359             nan     0.0500    0.0023
     4        0.0337             nan     0.0500    0.0022
     5        0.0315             nan     0.0500    0.0018
     6        0.0295             nan     0.0500    0.0013
     7        0.0274             nan     0.0500    0.0008
     8        0.0260             nan     0.0500    0.0011
     9        0.0245             nan     0.0500    0.0014
    10        0.0230             nan     0.0500    0.0014
    20        0.0141             nan     0.0500    0.0002
    40        0.0059             nan     0.0500    0.0003
    60        0.0033             nan     0.0500    0.0000
    80        0.0019             nan     0.0500   -0.0000
   100        0.0011             nan     0.0500   -0.0000
   120        0.0006             nan     0.0500   -0.0000
   140        0.0004             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0002             nan     0.0500    0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold19: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold19: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0399             nan     0.0500    0.0017
     2        0.0393             nan     0.0500   -0.0007
     3        0.0373             nan     0.0500    0.0015
     4        0.0357             nan     0.0500    0.0015
     5        0.0335             nan     0.0500    0.0014
     6        0.0319             nan     0.0500    0.0013
     7        0.0300             nan     0.0500    0.0019
     8        0.0278             nan     0.0500    0.0017
     9        0.0265             nan     0.0500    0.0004
    10        0.0246             nan     0.0500    0.0015
    20        0.0157             nan     0.0500    0.0005
    40        0.0064             nan     0.0500    0.0000
    60        0.0032             nan     0.0500   -0.0001
    80        0.0018             nan     0.0500    0.0000
   100        0.0011             nan     0.0500   -0.0000
   120        0.0008             nan     0.0500   -0.0000
   140        0.0005             nan     0.0500    0.0000
   160        0.0003             nan     0.0500   -0.0000
   180        0.0002             nan     0.0500    0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold19: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold19: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0401             nan     0.0500    0.0023
     2        0.0379             nan     0.0500    0.0024
     3        0.0360             nan     0.0500    0.0012
     4        0.0341             nan     0.0500    0.0017
     5        0.0322             nan     0.0500    0.0017
     6        0.0308             nan     0.0500    0.0005
     7        0.0282             nan     0.0500    0.0013
     8        0.0264             nan     0.0500    0.0014
     9        0.0247             nan     0.0500    0.0011
    10        0.0237             nan     0.0500    0.0007
    20        0.0161             nan     0.0500    0.0001
    40        0.0090             nan     0.0500    0.0001
    60        0.0051             nan     0.0500    0.0000
    80        0.0034             nan     0.0500   -0.0000
   100        0.0025             nan     0.0500    0.0000
   120        0.0017             nan     0.0500   -0.0000
   140        0.0012             nan     0.0500    0.0000
   160        0.0009             nan     0.0500    0.0000
   180        0.0007             nan     0.0500   -0.0000
   200        0.0005             nan     0.0500   -0.0000

- Fold19: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold19: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0401             nan     0.0500    0.0023
     2        0.0376             nan     0.0500    0.0018
     3        0.0360             nan     0.0500    0.0014
     4        0.0337             nan     0.0500    0.0019
     5        0.0305             nan     0.0500    0.0021
     6        0.0288             nan     0.0500    0.0008
     7        0.0266             nan     0.0500    0.0009
     8        0.0250             nan     0.0500    0.0010
     9        0.0235             nan     0.0500    0.0011
    10        0.0215             nan     0.0500    0.0010
    20        0.0109             nan     0.0500    0.0006
    40        0.0038             nan     0.0500    0.0002
    60        0.0015             nan     0.0500   -0.0000
    80        0.0007             nan     0.0500    0.0000
   100        0.0003             nan     0.0500    0.0000
   120        0.0002             nan     0.0500   -0.0000
   140        0.0001             nan     0.0500    0.0000
   160        0.0000             nan     0.0500    0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold19: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold19: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0405             nan     0.0500    0.0021
     2        0.0375             nan     0.0500    0.0023
     3        0.0351             nan     0.0500    0.0025
     4        0.0327             nan     0.0500    0.0021
     5        0.0305             nan     0.0500    0.0007
     6        0.0291             nan     0.0500    0.0010
     7        0.0272             nan     0.0500    0.0011
     8        0.0261             nan     0.0500    0.0015
     9        0.0240             nan     0.0500    0.0020
    10        0.0223             nan     0.0500    0.0009
    20        0.0118             nan     0.0500    0.0004
    40        0.0046             nan     0.0500    0.0000
    60        0.0020             nan     0.0500   -0.0000
    80        0.0010             nan     0.0500    0.0000
   100        0.0006             nan     0.0500   -0.0000
   120        0.0003             nan     0.0500    0.0000
   140        0.0002             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold19: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold19: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0409             nan     0.0500    0.0019
     2        0.0382             nan     0.0500    0.0024
     3        0.0360             nan     0.0500    0.0022
     4        0.0335             nan     0.0500    0.0020
     5        0.0314             nan     0.0500    0.0012
     6        0.0307             nan     0.0500   -0.0004
     7        0.0288             nan     0.0500    0.0019
     8        0.0270             nan     0.0500    0.0016
     9        0.0259             nan     0.0500    0.0006
    10        0.0246             nan     0.0500    0.0013
    20        0.0147             nan     0.0500    0.0007
    40        0.0072             nan     0.0500   -0.0001
    60        0.0045             nan     0.0500    0.0001
    80        0.0030             nan     0.0500    0.0000
   100        0.0019             nan     0.0500   -0.0000
   120        0.0013             nan     0.0500   -0.0000
   140        0.0009             nan     0.0500   -0.0000
   160        0.0006             nan     0.0500    0.0000
   180        0.0005             nan     0.0500   -0.0000
   200        0.0003             nan     0.0500    0.0000

- Fold19: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold19: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0403             nan     0.0500    0.0022
     2        0.0369             nan     0.0500    0.0026
     3        0.0338             nan     0.0500    0.0019
     4        0.0310             nan     0.0500    0.0017
     5        0.0288             nan     0.0500    0.0015
     6        0.0268             nan     0.0500    0.0023
     7        0.0247             nan     0.0500    0.0022
     8        0.0230             nan     0.0500    0.0014
     9        0.0215             nan     0.0500    0.0009
    10        0.0200             nan     0.0500    0.0020
    20        0.0104             nan     0.0500    0.0008
    40        0.0029             nan     0.0500    0.0000
    60        0.0010             nan     0.0500   -0.0000
    80        0.0004             nan     0.0500   -0.0000
   100        0.0002             nan     0.0500   -0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0000             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500    0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold19: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold19: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0412             nan     0.0500    0.0007
     2        0.0395             nan     0.0500    0.0022
     3        0.0374             nan     0.0500    0.0002
     4        0.0349             nan     0.0500    0.0027
     5        0.0320             nan     0.0500    0.0022
     6        0.0303             nan     0.0500    0.0018
     7        0.0289             nan     0.0500    0.0004
     8        0.0280             nan     0.0500    0.0002
     9        0.0260             nan     0.0500    0.0015
    10        0.0244             nan     0.0500    0.0006
    20        0.0133             nan     0.0500    0.0004
    40        0.0043             nan     0.0500    0.0001
    60        0.0018             nan     0.0500   -0.0000
    80        0.0009             nan     0.0500   -0.0000
   100        0.0005             nan     0.0500   -0.0000
   120        0.0003             nan     0.0500   -0.0000
   140        0.0002             nan     0.0500   -0.0000
   160        0.0001             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold19: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold19: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0411             nan     0.0500    0.0009
     2        0.0398             nan     0.0500    0.0009
     3        0.0369             nan     0.0500    0.0028
     4        0.0350             nan     0.0500    0.0010
     5        0.0335             nan     0.0500    0.0002
     6        0.0318             nan     0.0500    0.0007
     7        0.0306             nan     0.0500    0.0003
     8        0.0285             nan     0.0500    0.0019
     9        0.0273             nan     0.0500    0.0009
    10        0.0262             nan     0.0500    0.0008
    20        0.0165             nan     0.0500    0.0004
    40        0.0080             nan     0.0500    0.0002
    60        0.0045             nan     0.0500   -0.0000
    80        0.0028             nan     0.0500   -0.0000
   100        0.0020             nan     0.0500    0.0000
   120        0.0013             nan     0.0500   -0.0000
   140        0.0010             nan     0.0500    0.0000
   160        0.0007             nan     0.0500    0.0000
   180        0.0005             nan     0.0500   -0.0000
   200        0.0004             nan     0.0500   -0.0000

- Fold19: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold19: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0413             nan     0.1000   -0.0006
     2        0.0361             nan     0.1000    0.0047
     3        0.0309             nan     0.1000    0.0024
     4        0.0292             nan     0.1000    0.0008
     5        0.0266             nan     0.1000    0.0011
     6        0.0244             nan     0.1000    0.0013
     7        0.0211             nan     0.1000    0.0027
     8        0.0194             nan     0.1000    0.0002
     9        0.0188             nan     0.1000   -0.0004
    10        0.0179             nan     0.1000    0.0005
    20        0.0070             nan     0.1000    0.0006
    40        0.0019             nan     0.1000   -0.0002
    60        0.0006             nan     0.1000   -0.0000
    80        0.0003             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold19: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold19: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0404             nan     0.1000    0.0004
     2        0.0369             nan     0.1000    0.0006
     3        0.0331             nan     0.1000    0.0037
     4        0.0311             nan     0.1000    0.0011
     5        0.0284             nan     0.1000    0.0003
     6        0.0250             nan     0.1000    0.0031
     7        0.0239             nan     0.1000   -0.0003
     8        0.0222             nan     0.1000    0.0010
     9        0.0194             nan     0.1000    0.0009
    10        0.0176             nan     0.1000    0.0013
    20        0.0069             nan     0.1000    0.0000
    40        0.0023             nan     0.1000   -0.0001
    60        0.0008             nan     0.1000   -0.0000
    80        0.0003             nan     0.1000    0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000    0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold19: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold19: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0377             nan     0.1000    0.0052
     2        0.0326             nan     0.1000    0.0037
     3        0.0301             nan     0.1000    0.0017
     4        0.0268             nan     0.1000    0.0028
     5        0.0237             nan     0.1000    0.0029
     6        0.0219             nan     0.1000    0.0009
     7        0.0214             nan     0.1000    0.0001
     8        0.0194             nan     0.1000    0.0006
     9        0.0174             nan     0.1000    0.0012
    10        0.0161             nan     0.1000    0.0006
    20        0.0097             nan     0.1000   -0.0003
    40        0.0033             nan     0.1000   -0.0001
    60        0.0015             nan     0.1000   -0.0000
    80        0.0007             nan     0.1000    0.0000
   100        0.0004             nan     0.1000   -0.0000
   120        0.0002             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000    0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000    0.0000

- Fold19: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold19: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0373             nan     0.1000    0.0053
     2        0.0337             nan     0.1000    0.0002
     3        0.0291             nan     0.1000    0.0046
     4        0.0272             nan     0.1000   -0.0007
     5        0.0239             nan     0.1000    0.0019
     6        0.0210             nan     0.1000    0.0021
     7        0.0179             nan     0.1000    0.0016
     8        0.0158             nan     0.1000    0.0014
     9        0.0130             nan     0.1000    0.0020
    10        0.0116             nan     0.1000    0.0011
    20        0.0044             nan     0.1000    0.0002
    40        0.0010             nan     0.1000    0.0002
    60        0.0003             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold19: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold19: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0365             nan     0.1000    0.0060
     2        0.0305             nan     0.1000    0.0036
     3        0.0271             nan     0.1000    0.0010
     4        0.0229             nan     0.1000    0.0012
     5        0.0207             nan     0.1000    0.0012
     6        0.0178             nan     0.1000    0.0019
     7        0.0160             nan     0.1000    0.0016
     8        0.0149             nan     0.1000   -0.0006
     9        0.0128             nan     0.1000    0.0013
    10        0.0108             nan     0.1000    0.0013
    20        0.0037             nan     0.1000    0.0004
    40        0.0010             nan     0.1000   -0.0001
    60        0.0003             nan     0.1000   -0.0000
    80        0.0002             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000    0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold19: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold19: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0373             nan     0.1000    0.0056
     2        0.0340             nan     0.1000    0.0019
     3        0.0303             nan     0.1000    0.0027
     4        0.0274             nan     0.1000    0.0016
     5        0.0246             nan     0.1000    0.0019
     6        0.0220             nan     0.1000    0.0027
     7        0.0195             nan     0.1000    0.0022
     8        0.0175             nan     0.1000    0.0018
     9        0.0159             nan     0.1000    0.0016
    10        0.0148             nan     0.1000    0.0003
    20        0.0091             nan     0.1000   -0.0005
    40        0.0043             nan     0.1000   -0.0002
    60        0.0018             nan     0.1000    0.0000
    80        0.0009             nan     0.1000    0.0000
   100        0.0004             nan     0.1000   -0.0000
   120        0.0002             nan     0.1000    0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000    0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000    0.0000

- Fold19: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold19: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0356             nan     0.1000    0.0052
     2        0.0291             nan     0.1000    0.0045
     3        0.0249             nan     0.1000    0.0032
     4        0.0216             nan     0.1000    0.0024
     5        0.0192             nan     0.1000    0.0016
     6        0.0171             nan     0.1000    0.0009
     7        0.0145             nan     0.1000    0.0027
     8        0.0125             nan     0.1000    0.0017
     9        0.0108             nan     0.1000    0.0013
    10        0.0101             nan     0.1000    0.0005
    20        0.0034             nan     0.1000   -0.0001
    40        0.0007             nan     0.1000   -0.0001
    60        0.0002             nan     0.1000   -0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000    0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000    0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold19: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold19: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0352             nan     0.1000    0.0029
     2        0.0312             nan     0.1000    0.0027
     3        0.0276             nan     0.1000    0.0028
     4        0.0238             nan     0.1000    0.0037
     5        0.0200             nan     0.1000    0.0036
     6        0.0188             nan     0.1000    0.0004
     7        0.0170             nan     0.1000    0.0003
     8        0.0153             nan     0.1000    0.0013
     9        0.0126             nan     0.1000    0.0015
    10        0.0113             nan     0.1000    0.0006
    20        0.0045             nan     0.1000    0.0005
    40        0.0009             nan     0.1000    0.0000
    60        0.0003             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000    0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold19: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold19: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0369             nan     0.1000    0.0056
     2        0.0330             nan     0.1000    0.0041
     3        0.0296             nan     0.1000    0.0038
     4        0.0259             nan     0.1000    0.0010
     5        0.0237             nan     0.1000    0.0010
     6        0.0208             nan     0.1000    0.0023
     7        0.0192             nan     0.1000    0.0012
     8        0.0177             nan     0.1000    0.0015
     9        0.0162             nan     0.1000    0.0013
    10        0.0148             nan     0.1000    0.0015
    20        0.0098             nan     0.1000   -0.0004
    40        0.0035             nan     0.1000    0.0001
    60        0.0012             nan     0.1000    0.0001
    80        0.0007             nan     0.1000   -0.0000
   100        0.0003             nan     0.1000   -0.0000
   120        0.0002             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold19: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold20: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0433             nan     0.0100    0.0006
     2        0.0430             nan     0.0100    0.0001
     3        0.0424             nan     0.0100    0.0005
     4        0.0420             nan     0.0100    0.0003
     5        0.0416             nan     0.0100    0.0003
     6        0.0410             nan     0.0100    0.0006
     7        0.0408             nan     0.0100   -0.0002
     8        0.0403             nan     0.0100    0.0005
     9        0.0398             nan     0.0100    0.0004
    10        0.0393             nan     0.0100    0.0002
    20        0.0346             nan     0.0100    0.0003
    40        0.0275             nan     0.0100    0.0002
    60        0.0225             nan     0.0100    0.0003
    80        0.0179             nan     0.0100    0.0002
   100        0.0145             nan     0.0100    0.0002
   120        0.0119             nan     0.0100    0.0001
   140        0.0098             nan     0.0100    0.0001
   160        0.0080             nan     0.0100    0.0001
   180        0.0067             nan     0.0100    0.0000
   200        0.0056             nan     0.0100   -0.0000

- Fold20: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold20: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0436             nan     0.0100    0.0003
     2        0.0429             nan     0.0100    0.0005
     3        0.0424             nan     0.0100    0.0003
     4        0.0418             nan     0.0100    0.0004
     5        0.0413             nan     0.0100    0.0005
     6        0.0408             nan     0.0100    0.0005
     7        0.0403             nan     0.0100    0.0006
     8        0.0397             nan     0.0100    0.0007
     9        0.0393             nan     0.0100    0.0002
    10        0.0387             nan     0.0100    0.0005
    20        0.0350             nan     0.0100    0.0004
    40        0.0277             nan     0.0100    0.0001
    60        0.0226             nan     0.0100    0.0002
    80        0.0184             nan     0.0100    0.0002
   100        0.0154             nan     0.0100    0.0002
   120        0.0127             nan     0.0100    0.0001
   140        0.0107             nan     0.0100    0.0001
   160        0.0090             nan     0.0100    0.0001
   180        0.0076             nan     0.0100    0.0001
   200        0.0066             nan     0.0100    0.0001

- Fold20: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold20: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0433             nan     0.0100    0.0006
     2        0.0427             nan     0.0100    0.0001
     3        0.0420             nan     0.0100    0.0005
     4        0.0414             nan     0.0100    0.0005
     5        0.0409             nan     0.0100    0.0005
     6        0.0403             nan     0.0100    0.0006
     7        0.0400             nan     0.0100    0.0004
     8        0.0394             nan     0.0100    0.0005
     9        0.0389             nan     0.0100    0.0001
    10        0.0385             nan     0.0100    0.0004
    20        0.0343             nan     0.0100    0.0000
    40        0.0274             nan     0.0100    0.0002
    60        0.0228             nan     0.0100    0.0000
    80        0.0184             nan     0.0100    0.0002
   100        0.0155             nan     0.0100    0.0001
   120        0.0132             nan     0.0100   -0.0000
   140        0.0114             nan     0.0100    0.0001
   160        0.0099             nan     0.0100    0.0000
   180        0.0087             nan     0.0100    0.0001
   200        0.0078             nan     0.0100    0.0000

- Fold20: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold20: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0432             nan     0.0100    0.0006
     2        0.0425             nan     0.0100    0.0007
     3        0.0421             nan     0.0100    0.0003
     4        0.0414             nan     0.0100    0.0006
     5        0.0407             nan     0.0100    0.0005
     6        0.0402             nan     0.0100    0.0001
     7        0.0398             nan     0.0100    0.0004
     8        0.0393             nan     0.0100    0.0005
     9        0.0387             nan     0.0100    0.0005
    10        0.0382             nan     0.0100    0.0002
    20        0.0328             nan     0.0100    0.0003
    40        0.0252             nan     0.0100    0.0002
    60        0.0192             nan     0.0100    0.0003
    80        0.0147             nan     0.0100    0.0002
   100        0.0119             nan     0.0100    0.0001
   120        0.0096             nan     0.0100    0.0001
   140        0.0077             nan     0.0100    0.0001
   160        0.0062             nan     0.0100    0.0000
   180        0.0050             nan     0.0100   -0.0000
   200        0.0042             nan     0.0100    0.0000

- Fold20: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold20: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0436             nan     0.0100    0.0001
     2        0.0429             nan     0.0100    0.0006
     3        0.0424             nan     0.0100    0.0005
     4        0.0417             nan     0.0100    0.0005
     5        0.0412             nan     0.0100    0.0006
     6        0.0406             nan     0.0100    0.0006
     7        0.0400             nan     0.0100    0.0005
     8        0.0394             nan     0.0100    0.0004
     9        0.0388             nan     0.0100    0.0006
    10        0.0381             nan     0.0100    0.0005
    20        0.0332             nan     0.0100    0.0004
    40        0.0254             nan     0.0100    0.0002
    60        0.0199             nan     0.0100    0.0000
    80        0.0159             nan     0.0100    0.0002
   100        0.0125             nan     0.0100    0.0002
   120        0.0100             nan     0.0100    0.0000
   140        0.0080             nan     0.0100   -0.0000
   160        0.0066             nan     0.0100    0.0000
   180        0.0054             nan     0.0100    0.0000
   200        0.0044             nan     0.0100    0.0000

- Fold20: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold20: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0434             nan     0.0100    0.0004
     2        0.0431             nan     0.0100   -0.0001
     3        0.0425             nan     0.0100    0.0006
     4        0.0419             nan     0.0100    0.0005
     5        0.0413             nan     0.0100    0.0006
     6        0.0406             nan     0.0100    0.0005
     7        0.0401             nan     0.0100    0.0002
     8        0.0398             nan     0.0100    0.0002
     9        0.0392             nan     0.0100    0.0006
    10        0.0388             nan     0.0100    0.0002
    20        0.0346             nan     0.0100    0.0002
    40        0.0276             nan     0.0100    0.0003
    60        0.0222             nan     0.0100    0.0001
    80        0.0183             nan     0.0100    0.0001
   100        0.0152             nan     0.0100    0.0001
   120        0.0128             nan     0.0100    0.0001
   140        0.0110             nan     0.0100    0.0001
   160        0.0096             nan     0.0100   -0.0000
   180        0.0085             nan     0.0100    0.0001
   200        0.0076             nan     0.0100    0.0000

- Fold20: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold20: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0432             nan     0.0100    0.0006
     2        0.0426             nan     0.0100    0.0005
     3        0.0420             nan     0.0100    0.0003
     4        0.0417             nan     0.0100   -0.0001
     5        0.0411             nan     0.0100    0.0005
     6        0.0406             nan     0.0100    0.0005
     7        0.0399             nan     0.0100    0.0004
     8        0.0394             nan     0.0100    0.0004
     9        0.0388             nan     0.0100    0.0004
    10        0.0383             nan     0.0100    0.0004
    20        0.0325             nan     0.0100    0.0002
    40        0.0250             nan     0.0100    0.0002
    60        0.0189             nan     0.0100    0.0001
    80        0.0148             nan     0.0100    0.0002
   100        0.0113             nan     0.0100    0.0001
   120        0.0089             nan     0.0100    0.0001
   140        0.0068             nan     0.0100    0.0001
   160        0.0054             nan     0.0100   -0.0000
   180        0.0043             nan     0.0100    0.0000
   200        0.0034             nan     0.0100    0.0000

- Fold20: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold20: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0431             nan     0.0100    0.0004
     2        0.0427             nan     0.0100    0.0003
     3        0.0422             nan     0.0100    0.0004
     4        0.0417             nan     0.0100    0.0004
     5        0.0410             nan     0.0100    0.0006
     6        0.0405             nan     0.0100    0.0004
     7        0.0398             nan     0.0100    0.0007
     8        0.0392             nan     0.0100    0.0004
     9        0.0387             nan     0.0100    0.0004
    10        0.0382             nan     0.0100    0.0001
    20        0.0332             nan     0.0100    0.0003
    40        0.0255             nan     0.0100    0.0001
    60        0.0192             nan     0.0100    0.0003
    80        0.0154             nan     0.0100    0.0001
   100        0.0121             nan     0.0100    0.0000
   120        0.0095             nan     0.0100    0.0000
   140        0.0076             nan     0.0100    0.0001
   160        0.0059             nan     0.0100    0.0000
   180        0.0047             nan     0.0100    0.0001
   200        0.0039             nan     0.0100    0.0000

- Fold20: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold20: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0435             nan     0.0100    0.0005
     2        0.0428             nan     0.0100    0.0005
     3        0.0419             nan     0.0100    0.0006
     4        0.0415             nan     0.0100    0.0006
     5        0.0409             nan     0.0100    0.0002
     6        0.0404             nan     0.0100    0.0005
     7        0.0401             nan     0.0100    0.0002
     8        0.0396             nan     0.0100    0.0002
     9        0.0393             nan     0.0100    0.0002
    10        0.0390             nan     0.0100    0.0003
    20        0.0348             nan     0.0100    0.0004
    40        0.0280             nan     0.0100    0.0001
    60        0.0227             nan     0.0100    0.0000
    80        0.0185             nan     0.0100    0.0002
   100        0.0152             nan     0.0100    0.0001
   120        0.0131             nan     0.0100    0.0001
   140        0.0113             nan     0.0100    0.0001
   160        0.0098             nan     0.0100    0.0000
   180        0.0088             nan     0.0100   -0.0000
   200        0.0078             nan     0.0100    0.0000

- Fold20: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold20: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0410             nan     0.0500    0.0028
     2        0.0382             nan     0.0500    0.0023
     3        0.0362             nan     0.0500    0.0024
     4        0.0343             nan     0.0500    0.0019
     5        0.0322             nan     0.0500    0.0020
     6        0.0302             nan     0.0500    0.0017
     7        0.0290             nan     0.0500    0.0010
     8        0.0272             nan     0.0500    0.0018
     9        0.0262             nan     0.0500    0.0007
    10        0.0254             nan     0.0500    0.0002
    20        0.0155             nan     0.0500    0.0004
    40        0.0069             nan     0.0500   -0.0001
    60        0.0034             nan     0.0500    0.0001
    80        0.0017             nan     0.0500    0.0000
   100        0.0011             nan     0.0500   -0.0001
   120        0.0007             nan     0.0500    0.0000
   140        0.0004             nan     0.0500   -0.0000
   160        0.0003             nan     0.0500   -0.0000
   180        0.0002             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold20: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold20: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0409             nan     0.0500    0.0030
     2        0.0390             nan     0.0500    0.0016
     3        0.0365             nan     0.0500    0.0014
     4        0.0340             nan     0.0500    0.0026
     5        0.0325             nan     0.0500   -0.0001
     6        0.0299             nan     0.0500    0.0025
     7        0.0285             nan     0.0500    0.0017
     8        0.0268             nan     0.0500    0.0015
     9        0.0250             nan     0.0500    0.0012
    10        0.0233             nan     0.0500    0.0015
    20        0.0141             nan     0.0500    0.0007
    40        0.0061             nan     0.0500    0.0003
    60        0.0031             nan     0.0500   -0.0001
    80        0.0018             nan     0.0500    0.0000
   100        0.0011             nan     0.0500    0.0000
   120        0.0007             nan     0.0500    0.0000
   140        0.0005             nan     0.0500    0.0000
   160        0.0003             nan     0.0500    0.0000
   180        0.0002             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500    0.0000

- Fold20: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold20: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0416             nan     0.0500    0.0029
     2        0.0392             nan     0.0500    0.0021
     3        0.0375             nan     0.0500    0.0023
     4        0.0351             nan     0.0500    0.0016
     5        0.0330             nan     0.0500    0.0021
     6        0.0311             nan     0.0500    0.0017
     7        0.0295             nan     0.0500    0.0015
     8        0.0284             nan     0.0500    0.0001
     9        0.0274             nan     0.0500   -0.0003
    10        0.0269             nan     0.0500   -0.0004
    20        0.0176             nan     0.0500    0.0009
    40        0.0094             nan     0.0500    0.0001
    60        0.0052             nan     0.0500   -0.0000
    80        0.0035             nan     0.0500   -0.0001
   100        0.0025             nan     0.0500   -0.0000
   120        0.0017             nan     0.0500    0.0000
   140        0.0012             nan     0.0500    0.0000
   160        0.0009             nan     0.0500   -0.0000
   180        0.0007             nan     0.0500   -0.0000
   200        0.0005             nan     0.0500   -0.0000

- Fold20: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold20: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0414             nan     0.0500    0.0019
     2        0.0381             nan     0.0500    0.0020
     3        0.0363             nan     0.0500    0.0010
     4        0.0338             nan     0.0500    0.0020
     5        0.0309             nan     0.0500    0.0016
     6        0.0295             nan     0.0500    0.0014
     7        0.0276             nan     0.0500    0.0018
     8        0.0257             nan     0.0500    0.0019
     9        0.0235             nan     0.0500    0.0012
    10        0.0221             nan     0.0500    0.0014
    20        0.0134             nan     0.0500    0.0001
    40        0.0036             nan     0.0500    0.0001
    60        0.0015             nan     0.0500   -0.0000
    80        0.0007             nan     0.0500    0.0000
   100        0.0003             nan     0.0500   -0.0000
   120        0.0001             nan     0.0500    0.0000
   140        0.0001             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold20: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold20: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0408             nan     0.0500    0.0029
     2        0.0372             nan     0.0500    0.0033
     3        0.0357             nan     0.0500    0.0009
     4        0.0336             nan     0.0500    0.0017
     5        0.0314             nan     0.0500    0.0016
     6        0.0285             nan     0.0500    0.0014
     7        0.0274             nan     0.0500    0.0005
     8        0.0255             nan     0.0500    0.0005
     9        0.0239             nan     0.0500    0.0014
    10        0.0222             nan     0.0500    0.0018
    20        0.0137             nan     0.0500    0.0002
    40        0.0054             nan     0.0500   -0.0002
    60        0.0023             nan     0.0500    0.0001
    80        0.0011             nan     0.0500   -0.0000
   100        0.0007             nan     0.0500    0.0000
   120        0.0005             nan     0.0500   -0.0000
   140        0.0003             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold20: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold20: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0407             nan     0.0500    0.0025
     2        0.0379             nan     0.0500    0.0027
     3        0.0360             nan     0.0500   -0.0001
     4        0.0337             nan     0.0500    0.0016
     5        0.0317             nan     0.0500    0.0021
     6        0.0302             nan     0.0500    0.0017
     7        0.0281             nan     0.0500    0.0017
     8        0.0262             nan     0.0500    0.0014
     9        0.0254             nan     0.0500    0.0004
    10        0.0243             nan     0.0500    0.0014
    20        0.0161             nan     0.0500    0.0002
    40        0.0080             nan     0.0500   -0.0001
    60        0.0049             nan     0.0500   -0.0001
    80        0.0032             nan     0.0500   -0.0001
   100        0.0024             nan     0.0500   -0.0001
   120        0.0018             nan     0.0500    0.0000
   140        0.0013             nan     0.0500   -0.0000
   160        0.0009             nan     0.0500   -0.0000
   180        0.0007             nan     0.0500    0.0000
   200        0.0005             nan     0.0500   -0.0000

- Fold20: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold20: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0400             nan     0.0500    0.0046
     2        0.0366             nan     0.0500    0.0030
     3        0.0342             nan     0.0500    0.0023
     4        0.0314             nan     0.0500    0.0015
     5        0.0290             nan     0.0500    0.0013
     6        0.0261             nan     0.0500    0.0027
     7        0.0253             nan     0.0500   -0.0004
     8        0.0229             nan     0.0500    0.0009
     9        0.0213             nan     0.0500    0.0003
    10        0.0200             nan     0.0500    0.0007
    20        0.0104             nan     0.0500    0.0003
    40        0.0031             nan     0.0500   -0.0001
    60        0.0011             nan     0.0500   -0.0000
    80        0.0004             nan     0.0500   -0.0000
   100        0.0002             nan     0.0500   -0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0000             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold20: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold20: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0422             nan     0.0500    0.0016
     2        0.0392             nan     0.0500    0.0025
     3        0.0365             nan     0.0500    0.0029
     4        0.0344             nan     0.0500    0.0010
     5        0.0315             nan     0.0500    0.0028
     6        0.0295             nan     0.0500    0.0017
     7        0.0275             nan     0.0500    0.0003
     8        0.0252             nan     0.0500    0.0013
     9        0.0238             nan     0.0500    0.0009
    10        0.0223             nan     0.0500    0.0013
    20        0.0129             nan     0.0500    0.0002
    40        0.0049             nan     0.0500    0.0002
    60        0.0022             nan     0.0500    0.0001
    80        0.0012             nan     0.0500   -0.0000
   100        0.0006             nan     0.0500   -0.0000
   120        0.0004             nan     0.0500   -0.0000
   140        0.0003             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500    0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold20: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold20: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0416             nan     0.0500    0.0015
     2        0.0385             nan     0.0500    0.0021
     3        0.0369             nan     0.0500    0.0018
     4        0.0344             nan     0.0500    0.0010
     5        0.0328             nan     0.0500    0.0016
     6        0.0307             nan     0.0500    0.0022
     7        0.0287             nan     0.0500    0.0020
     8        0.0267             nan     0.0500    0.0016
     9        0.0255             nan     0.0500    0.0008
    10        0.0240             nan     0.0500    0.0015
    20        0.0148             nan     0.0500    0.0006
    40        0.0071             nan     0.0500    0.0002
    60        0.0047             nan     0.0500    0.0001
    80        0.0030             nan     0.0500    0.0000
   100        0.0021             nan     0.0500    0.0000
   120        0.0014             nan     0.0500    0.0000
   140        0.0011             nan     0.0500   -0.0000
   160        0.0008             nan     0.0500    0.0000
   180        0.0006             nan     0.0500   -0.0000
   200        0.0004             nan     0.0500   -0.0000

- Fold20: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold20: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0377             nan     0.1000    0.0042
     2        0.0327             nan     0.1000    0.0049
     3        0.0288             nan     0.1000    0.0019
     4        0.0253             nan     0.1000    0.0029
     5        0.0233             nan     0.1000   -0.0011
     6        0.0199             nan     0.1000    0.0038
     7        0.0172             nan     0.1000    0.0025
     8        0.0159             nan     0.1000    0.0012
     9        0.0140             nan     0.1000    0.0021
    10        0.0122             nan     0.1000    0.0021
    20        0.0051             nan     0.1000    0.0007
    40        0.0013             nan     0.1000    0.0001
    60        0.0005             nan     0.1000    0.0000
    80        0.0002             nan     0.1000    0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold20: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold20: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0400             nan     0.1000   -0.0007
     2        0.0343             nan     0.1000    0.0042
     3        0.0306             nan     0.1000    0.0042
     4        0.0272             nan     0.1000    0.0036
     5        0.0242             nan     0.1000    0.0013
     6        0.0224             nan     0.1000    0.0007
     7        0.0203             nan     0.1000    0.0015
     8        0.0181             nan     0.1000    0.0024
     9        0.0164             nan     0.1000    0.0011
    10        0.0147             nan     0.1000    0.0015
    20        0.0063             nan     0.1000    0.0002
    40        0.0019             nan     0.1000   -0.0002
    60        0.0009             nan     0.1000    0.0000
    80        0.0004             nan     0.1000    0.0000
   100        0.0002             nan     0.1000    0.0000
   120        0.0001             nan     0.1000    0.0000
   140        0.0000             nan     0.1000    0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000    0.0000
   200        0.0000             nan     0.1000    0.0000

- Fold20: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold20: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0392             nan     0.1000    0.0030
     2        0.0367             nan     0.1000    0.0024
     3        0.0318             nan     0.1000    0.0021
     4        0.0269             nan     0.1000    0.0031
     5        0.0235             nan     0.1000    0.0028
     6        0.0208             nan     0.1000    0.0016
     7        0.0194             nan     0.1000    0.0009
     8        0.0176             nan     0.1000    0.0017
     9        0.0162             nan     0.1000    0.0014
    10        0.0161             nan     0.1000   -0.0006
    20        0.0086             nan     0.1000    0.0005
    40        0.0038             nan     0.1000    0.0001
    60        0.0018             nan     0.1000   -0.0000
    80        0.0011             nan     0.1000   -0.0000
   100        0.0006             nan     0.1000    0.0000
   120        0.0004             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold20: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold20: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0380             nan     0.1000    0.0021
     2        0.0312             nan     0.1000    0.0049
     3        0.0284             nan     0.1000    0.0008
     4        0.0252             nan     0.1000    0.0033
     5        0.0217             nan     0.1000    0.0027
     6        0.0194             nan     0.1000    0.0019
     7        0.0169             nan     0.1000    0.0018
     8        0.0159             nan     0.1000   -0.0002
     9        0.0137             nan     0.1000    0.0007
    10        0.0122             nan     0.1000    0.0014
    20        0.0038             nan     0.1000    0.0003
    40        0.0006             nan     0.1000    0.0000
    60        0.0002             nan     0.1000   -0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold20: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold20: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0368             nan     0.1000    0.0064
     2        0.0341             nan     0.1000   -0.0011
     3        0.0303             nan     0.1000    0.0032
     4        0.0260             nan     0.1000    0.0020
     5        0.0233             nan     0.1000    0.0028
     6        0.0209             nan     0.1000    0.0018
     7        0.0198             nan     0.1000   -0.0010
     8        0.0181             nan     0.1000    0.0009
     9        0.0162             nan     0.1000    0.0010
    10        0.0145             nan     0.1000    0.0022
    20        0.0053             nan     0.1000    0.0004
    40        0.0012             nan     0.1000    0.0000
    60        0.0004             nan     0.1000    0.0000
    80        0.0002             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000    0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold20: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold20: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0392             nan     0.1000    0.0021
     2        0.0350             nan     0.1000    0.0046
     3        0.0314             nan     0.1000    0.0023
     4        0.0281             nan     0.1000    0.0031
     5        0.0252             nan     0.1000    0.0023
     6        0.0216             nan     0.1000    0.0022
     7        0.0198             nan     0.1000    0.0015
     8        0.0186             nan     0.1000    0.0005
     9        0.0163             nan     0.1000    0.0018
    10        0.0142             nan     0.1000    0.0014
    20        0.0060             nan     0.1000    0.0000
    40        0.0026             nan     0.1000    0.0001
    60        0.0012             nan     0.1000   -0.0000
    80        0.0009             nan     0.1000   -0.0001
   100        0.0004             nan     0.1000   -0.0000
   120        0.0003             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000    0.0000
   200        0.0000             nan     0.1000    0.0000

- Fold20: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold20: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0369             nan     0.1000    0.0071
     2        0.0317             nan     0.1000    0.0032
     3        0.0271             nan     0.1000    0.0029
     4        0.0223             nan     0.1000    0.0041
     5        0.0191             nan     0.1000    0.0018
     6        0.0178             nan     0.1000    0.0008
     7        0.0155             nan     0.1000    0.0013
     8        0.0135             nan     0.1000    0.0020
     9        0.0123             nan     0.1000    0.0006
    10        0.0115             nan     0.1000   -0.0010
    20        0.0041             nan     0.1000   -0.0001
    40        0.0006             nan     0.1000   -0.0000
    60        0.0001             nan     0.1000   -0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold20: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold20: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0377             nan     0.1000    0.0065
     2        0.0312             nan     0.1000    0.0052
     3        0.0255             nan     0.1000    0.0047
     4        0.0220             nan     0.1000    0.0025
     5        0.0188             nan     0.1000    0.0014
     6        0.0156             nan     0.1000    0.0018
     7        0.0135             nan     0.1000    0.0017
     8        0.0119             nan     0.1000    0.0009
     9        0.0102             nan     0.1000    0.0010
    10        0.0092             nan     0.1000    0.0008
    20        0.0033             nan     0.1000    0.0000
    40        0.0010             nan     0.1000   -0.0000
    60        0.0004             nan     0.1000   -0.0000
    80        0.0002             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000    0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold20: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold20: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0380             nan     0.1000    0.0029
     2        0.0327             nan     0.1000    0.0034
     3        0.0295             nan     0.1000    0.0023
     4        0.0257             nan     0.1000    0.0010
     5        0.0231             nan     0.1000    0.0023
     6        0.0228             nan     0.1000   -0.0019
     7        0.0208             nan     0.1000   -0.0007
     8        0.0187             nan     0.1000    0.0023
     9        0.0168             nan     0.1000    0.0012
    10        0.0149             nan     0.1000    0.0001
    20        0.0094             nan     0.1000   -0.0008
    40        0.0033             nan     0.1000   -0.0001
    60        0.0022             nan     0.1000   -0.0000
    80        0.0013             nan     0.1000   -0.0001
   100        0.0008             nan     0.1000   -0.0001
   120        0.0005             nan     0.1000    0.0000
   140        0.0003             nan     0.1000   -0.0000
   160        0.0002             nan     0.1000   -0.0000
   180        0.0002             nan     0.1000    0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold20: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold21: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0416             nan     0.0100    0.0001
     2        0.0411             nan     0.0100    0.0006
     3        0.0405             nan     0.0100    0.0006
     4        0.0401             nan     0.0100    0.0004
     5        0.0399             nan     0.0100    0.0000
     6        0.0396             nan     0.0100    0.0002
     7        0.0391             nan     0.0100    0.0003
     8        0.0388             nan     0.0100    0.0002
     9        0.0383             nan     0.0100    0.0005
    10        0.0379             nan     0.0100    0.0005
    20        0.0341             nan     0.0100   -0.0000
    40        0.0268             nan     0.0100    0.0003
    60        0.0225             nan     0.0100   -0.0000
    80        0.0180             nan     0.0100    0.0001
   100        0.0149             nan     0.0100    0.0001
   120        0.0123             nan     0.0100    0.0000
   140        0.0105             nan     0.0100   -0.0000
   160        0.0089             nan     0.0100    0.0001
   180        0.0075             nan     0.0100    0.0000
   200        0.0063             nan     0.0100    0.0000

- Fold21: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold21: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0414             nan     0.0100    0.0005
     2        0.0410             nan     0.0100    0.0004
     3        0.0404             nan     0.0100    0.0005
     4        0.0399             nan     0.0100    0.0005
     5        0.0394             nan     0.0100    0.0004
     6        0.0391             nan     0.0100    0.0000
     7        0.0386             nan     0.0100    0.0004
     8        0.0381             nan     0.0100    0.0006
     9        0.0377             nan     0.0100    0.0004
    10        0.0373             nan     0.0100    0.0004
    20        0.0333             nan     0.0100    0.0001
    40        0.0269             nan     0.0100    0.0003
    60        0.0217             nan     0.0100    0.0000
    80        0.0176             nan     0.0100    0.0002
   100        0.0144             nan     0.0100    0.0000
   120        0.0121             nan     0.0100    0.0000
   140        0.0102             nan     0.0100   -0.0001
   160        0.0087             nan     0.0100    0.0000
   180        0.0075             nan     0.0100    0.0000
   200        0.0065             nan     0.0100    0.0000

- Fold21: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold21: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0415             nan     0.0100    0.0001
     2        0.0414             nan     0.0100    0.0001
     3        0.0409             nan     0.0100    0.0005
     4        0.0402             nan     0.0100    0.0005
     5        0.0398             nan     0.0100    0.0004
     6        0.0393             nan     0.0100    0.0003
     7        0.0388             nan     0.0100    0.0004
     8        0.0382             nan     0.0100    0.0005
     9        0.0379             nan     0.0100    0.0003
    10        0.0375             nan     0.0100    0.0002
    20        0.0337             nan     0.0100    0.0004
    40        0.0268             nan     0.0100    0.0003
    60        0.0218             nan     0.0100    0.0002
    80        0.0181             nan     0.0100    0.0001
   100        0.0151             nan     0.0100    0.0000
   120        0.0131             nan     0.0100   -0.0000
   140        0.0114             nan     0.0100   -0.0000
   160        0.0102             nan     0.0100    0.0000
   180        0.0090             nan     0.0100    0.0000
   200        0.0079             nan     0.0100    0.0000

- Fold21: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold21: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0417             nan     0.0100   -0.0003
     2        0.0410             nan     0.0100    0.0006
     3        0.0405             nan     0.0100    0.0003
     4        0.0400             nan     0.0100    0.0006
     5        0.0394             nan     0.0100    0.0006
     6        0.0388             nan     0.0100    0.0005
     7        0.0382             nan     0.0100    0.0004
     8        0.0378             nan     0.0100    0.0002
     9        0.0373             nan     0.0100    0.0003
    10        0.0371             nan     0.0100    0.0001
    20        0.0322             nan     0.0100    0.0003
    40        0.0241             nan     0.0100    0.0002
    60        0.0184             nan     0.0100    0.0001
    80        0.0143             nan     0.0100    0.0002
   100        0.0115             nan     0.0100    0.0000
   120        0.0092             nan     0.0100    0.0001
   140        0.0074             nan     0.0100    0.0001
   160        0.0058             nan     0.0100    0.0000
   180        0.0047             nan     0.0100    0.0000
   200        0.0039             nan     0.0100    0.0000

- Fold21: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold21: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0415             nan     0.0100    0.0004
     2        0.0409             nan     0.0100    0.0002
     3        0.0404             nan     0.0100    0.0006
     4        0.0399             nan     0.0100    0.0004
     5        0.0394             nan     0.0100    0.0005
     6        0.0389             nan     0.0100    0.0004
     7        0.0384             nan     0.0100    0.0004
     8        0.0378             nan     0.0100    0.0006
     9        0.0373             nan     0.0100    0.0004
    10        0.0369             nan     0.0100    0.0005
    20        0.0317             nan     0.0100    0.0002
    40        0.0245             nan     0.0100    0.0004
    60        0.0197             nan     0.0100    0.0001
    80        0.0156             nan     0.0100    0.0001
   100        0.0123             nan     0.0100    0.0001
   120        0.0097             nan     0.0100    0.0001
   140        0.0077             nan     0.0100    0.0000
   160        0.0062             nan     0.0100   -0.0000
   180        0.0052             nan     0.0100    0.0000
   200        0.0043             nan     0.0100    0.0000

- Fold21: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold21: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0414             nan     0.0100    0.0005
     2        0.0411             nan     0.0100    0.0002
     3        0.0405             nan     0.0100    0.0006
     4        0.0399             nan     0.0100    0.0005
     5        0.0398             nan     0.0100   -0.0001
     6        0.0392             nan     0.0100    0.0004
     7        0.0387             nan     0.0100    0.0005
     8        0.0383             nan     0.0100    0.0004
     9        0.0379             nan     0.0100    0.0005
    10        0.0373             nan     0.0100    0.0005
    20        0.0329             nan     0.0100    0.0004
    40        0.0273             nan     0.0100    0.0002
    60        0.0228             nan     0.0100    0.0001
    80        0.0189             nan     0.0100    0.0002
   100        0.0159             nan     0.0100    0.0001
   120        0.0135             nan     0.0100    0.0001
   140        0.0115             nan     0.0100    0.0001
   160        0.0102             nan     0.0100    0.0001
   180        0.0092             nan     0.0100    0.0000
   200        0.0082             nan     0.0100   -0.0000

- Fold21: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold21: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0415             nan     0.0100    0.0003
     2        0.0407             nan     0.0100    0.0008
     3        0.0401             nan     0.0100    0.0004
     4        0.0396             nan     0.0100    0.0002
     5        0.0391             nan     0.0100    0.0005
     6        0.0386             nan     0.0100    0.0001
     7        0.0379             nan     0.0100    0.0003
     8        0.0373             nan     0.0100    0.0006
     9        0.0368             nan     0.0100    0.0004
    10        0.0361             nan     0.0100    0.0004
    20        0.0312             nan     0.0100    0.0003
    40        0.0242             nan     0.0100    0.0003
    60        0.0180             nan     0.0100    0.0002
    80        0.0136             nan     0.0100    0.0002
   100        0.0106             nan     0.0100    0.0001
   120        0.0080             nan     0.0100    0.0000
   140        0.0062             nan     0.0100    0.0000
   160        0.0050             nan     0.0100    0.0000
   180        0.0040             nan     0.0100    0.0000
   200        0.0032             nan     0.0100   -0.0000

- Fold21: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold21: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0412             nan     0.0100    0.0006
     2        0.0408             nan     0.0100    0.0004
     3        0.0401             nan     0.0100    0.0005
     4        0.0395             nan     0.0100    0.0006
     5        0.0390             nan     0.0100    0.0004
     6        0.0383             nan     0.0100    0.0003
     7        0.0378             nan     0.0100    0.0006
     8        0.0374             nan     0.0100    0.0002
     9        0.0368             nan     0.0100    0.0005
    10        0.0364             nan     0.0100    0.0006
    20        0.0322             nan     0.0100    0.0001
    40        0.0239             nan     0.0100    0.0002
    60        0.0185             nan     0.0100    0.0003
    80        0.0141             nan     0.0100    0.0000
   100        0.0110             nan     0.0100    0.0001
   120        0.0085             nan     0.0100    0.0000
   140        0.0069             nan     0.0100    0.0000
   160        0.0056             nan     0.0100    0.0000
   180        0.0047             nan     0.0100   -0.0000
   200        0.0039             nan     0.0100    0.0000

- Fold21: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold21: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0417             nan     0.0100   -0.0000
     2        0.0413             nan     0.0100    0.0001
     3        0.0407             nan     0.0100    0.0005
     4        0.0401             nan     0.0100    0.0004
     5        0.0396             nan     0.0100    0.0005
     6        0.0391             nan     0.0100    0.0004
     7        0.0386             nan     0.0100    0.0005
     8        0.0382             nan     0.0100    0.0004
     9        0.0378             nan     0.0100    0.0004
    10        0.0373             nan     0.0100    0.0005
    20        0.0331             nan     0.0100    0.0003
    40        0.0270             nan     0.0100    0.0000
    60        0.0216             nan     0.0100    0.0001
    80        0.0176             nan     0.0100    0.0001
   100        0.0148             nan     0.0100    0.0001
   120        0.0130             nan     0.0100    0.0001
   140        0.0113             nan     0.0100    0.0000
   160        0.0098             nan     0.0100    0.0000
   180        0.0089             nan     0.0100    0.0000
   200        0.0080             nan     0.0100   -0.0000

- Fold21: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold21: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0394             nan     0.0500    0.0024
     2        0.0381             nan     0.0500    0.0007
     3        0.0361             nan     0.0500    0.0007
     4        0.0335             nan     0.0500    0.0012
     5        0.0317             nan     0.0500    0.0018
     6        0.0301             nan     0.0500    0.0002
     7        0.0283             nan     0.0500    0.0007
     8        0.0266             nan     0.0500    0.0018
     9        0.0261             nan     0.0500    0.0003
    10        0.0246             nan     0.0500    0.0012
    20        0.0144             nan     0.0500    0.0008
    40        0.0067             nan     0.0500    0.0003
    60        0.0036             nan     0.0500   -0.0002
    80        0.0020             nan     0.0500    0.0000
   100        0.0012             nan     0.0500   -0.0000
   120        0.0007             nan     0.0500   -0.0000
   140        0.0004             nan     0.0500    0.0000
   160        0.0002             nan     0.0500    0.0000
   180        0.0002             nan     0.0500    0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold21: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold21: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0398             nan     0.0500    0.0011
     2        0.0376             nan     0.0500    0.0016
     3        0.0355             nan     0.0500    0.0023
     4        0.0334             nan     0.0500    0.0019
     5        0.0322             nan     0.0500    0.0007
     6        0.0301             nan     0.0500    0.0014
     7        0.0278             nan     0.0500    0.0021
     8        0.0262             nan     0.0500    0.0015
     9        0.0252             nan     0.0500    0.0010
    10        0.0245             nan     0.0500    0.0004
    20        0.0142             nan     0.0500    0.0007
    40        0.0060             nan     0.0500    0.0001
    60        0.0031             nan     0.0500    0.0001
    80        0.0019             nan     0.0500    0.0000
   100        0.0013             nan     0.0500    0.0000
   120        0.0010             nan     0.0500   -0.0000
   140        0.0006             nan     0.0500   -0.0000
   160        0.0004             nan     0.0500   -0.0000
   180        0.0003             nan     0.0500    0.0000
   200        0.0002             nan     0.0500   -0.0000

- Fold21: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold21: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0393             nan     0.0500    0.0027
     2        0.0373             nan     0.0500    0.0021
     3        0.0355             nan     0.0500    0.0017
     4        0.0331             nan     0.0500    0.0020
     5        0.0311             nan     0.0500    0.0011
     6        0.0291             nan     0.0500    0.0015
     7        0.0279             nan     0.0500    0.0010
     8        0.0268             nan     0.0500    0.0002
     9        0.0254             nan     0.0500    0.0014
    10        0.0238             nan     0.0500    0.0014
    20        0.0160             nan     0.0500    0.0003
    40        0.0086             nan     0.0500   -0.0001
    60        0.0055             nan     0.0500    0.0001
    80        0.0039             nan     0.0500   -0.0000
   100        0.0026             nan     0.0500   -0.0000
   120        0.0020             nan     0.0500   -0.0000
   140        0.0014             nan     0.0500   -0.0000
   160        0.0011             nan     0.0500   -0.0000
   180        0.0008             nan     0.0500   -0.0000
   200        0.0006             nan     0.0500    0.0000

- Fold21: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold21: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0385             nan     0.0500    0.0028
     2        0.0356             nan     0.0500    0.0028
     3        0.0322             nan     0.0500    0.0026
     4        0.0299             nan     0.0500    0.0023
     5        0.0281             nan     0.0500    0.0005
     6        0.0263             nan     0.0500    0.0012
     7        0.0240             nan     0.0500    0.0013
     8        0.0229             nan     0.0500    0.0001
     9        0.0219             nan     0.0500    0.0005
    10        0.0201             nan     0.0500    0.0011
    20        0.0090             nan     0.0500    0.0003
    40        0.0030             nan     0.0500    0.0001
    60        0.0012             nan     0.0500    0.0000
    80        0.0005             nan     0.0500   -0.0000
   100        0.0003             nan     0.0500   -0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0001             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500    0.0000

- Fold21: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold21: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0390             nan     0.0500    0.0014
     2        0.0367             nan     0.0500    0.0024
     3        0.0347             nan     0.0500    0.0016
     4        0.0318             nan     0.0500    0.0017
     5        0.0295             nan     0.0500    0.0020
     6        0.0274             nan     0.0500    0.0014
     7        0.0255             nan     0.0500    0.0022
     8        0.0246             nan     0.0500    0.0001
     9        0.0229             nan     0.0500    0.0016
    10        0.0216             nan     0.0500    0.0015
    20        0.0125             nan     0.0500    0.0005
    40        0.0050             nan     0.0500    0.0000
    60        0.0026             nan     0.0500   -0.0001
    80        0.0012             nan     0.0500    0.0000
   100        0.0007             nan     0.0500   -0.0000
   120        0.0004             nan     0.0500   -0.0000
   140        0.0003             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500    0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold21: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold21: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0392             nan     0.0500    0.0026
     2        0.0375             nan     0.0500    0.0020
     3        0.0356             nan     0.0500    0.0013
     4        0.0342             nan     0.0500    0.0001
     5        0.0324             nan     0.0500    0.0017
     6        0.0309             nan     0.0500    0.0009
     7        0.0289             nan     0.0500    0.0014
     8        0.0276             nan     0.0500    0.0016
     9        0.0263             nan     0.0500    0.0016
    10        0.0250             nan     0.0500    0.0014
    20        0.0152             nan     0.0500    0.0006
    40        0.0075             nan     0.0500    0.0002
    60        0.0049             nan     0.0500    0.0000
    80        0.0038             nan     0.0500   -0.0001
   100        0.0028             nan     0.0500    0.0000
   120        0.0022             nan     0.0500    0.0000
   140        0.0016             nan     0.0500    0.0000
   160        0.0012             nan     0.0500   -0.0000
   180        0.0009             nan     0.0500   -0.0000
   200        0.0007             nan     0.0500   -0.0000

- Fold21: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold21: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0397             nan     0.0500    0.0013
     2        0.0359             nan     0.0500    0.0035
     3        0.0338             nan     0.0500    0.0007
     4        0.0308             nan     0.0500    0.0021
     5        0.0283             nan     0.0500    0.0022
     6        0.0267             nan     0.0500    0.0014
     7        0.0247             nan     0.0500    0.0012
     8        0.0226             nan     0.0500    0.0015
     9        0.0213             nan     0.0500    0.0005
    10        0.0195             nan     0.0500    0.0018
    20        0.0095             nan     0.0500    0.0004
    40        0.0031             nan     0.0500    0.0001
    60        0.0011             nan     0.0500    0.0000
    80        0.0004             nan     0.0500   -0.0000
   100        0.0002             nan     0.0500   -0.0000
   120        0.0001             nan     0.0500    0.0000
   140        0.0000             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500    0.0000

- Fold21: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold21: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0382             nan     0.0500    0.0023
     2        0.0364             nan     0.0500    0.0007
     3        0.0339             nan     0.0500    0.0016
     4        0.0315             nan     0.0500    0.0010
     5        0.0298             nan     0.0500    0.0010
     6        0.0273             nan     0.0500    0.0011
     7        0.0253             nan     0.0500    0.0017
     8        0.0234             nan     0.0500    0.0020
     9        0.0216             nan     0.0500    0.0017
    10        0.0202             nan     0.0500    0.0013
    20        0.0107             nan     0.0500    0.0006
    40        0.0036             nan     0.0500    0.0001
    60        0.0016             nan     0.0500   -0.0000
    80        0.0008             nan     0.0500   -0.0000
   100        0.0005             nan     0.0500   -0.0000
   120        0.0003             nan     0.0500   -0.0000
   140        0.0002             nan     0.0500    0.0000
   160        0.0001             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500    0.0000

- Fold21: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold21: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0394             nan     0.0500    0.0020
     2        0.0373             nan     0.0500    0.0023
     3        0.0349             nan     0.0500    0.0025
     4        0.0326             nan     0.0500    0.0022
     5        0.0308             nan     0.0500    0.0013
     6        0.0288             nan     0.0500    0.0012
     7        0.0266             nan     0.0500    0.0013
     8        0.0254             nan     0.0500    0.0014
     9        0.0240             nan     0.0500    0.0013
    10        0.0227             nan     0.0500    0.0013
    20        0.0142             nan     0.0500    0.0007
    40        0.0073             nan     0.0500    0.0001
    60        0.0041             nan     0.0500   -0.0001
    80        0.0025             nan     0.0500    0.0000
   100        0.0018             nan     0.0500    0.0000
   120        0.0012             nan     0.0500    0.0000
   140        0.0008             nan     0.0500   -0.0000
   160        0.0007             nan     0.0500   -0.0000
   180        0.0005             nan     0.0500   -0.0000
   200        0.0003             nan     0.0500   -0.0000

- Fold21: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold21: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0385             nan     0.1000    0.0032
     2        0.0333             nan     0.1000    0.0046
     3        0.0307             nan     0.1000    0.0006
     4        0.0288             nan     0.1000    0.0015
     5        0.0277             nan     0.1000    0.0000
     6        0.0242             nan     0.1000    0.0029
     7        0.0219             nan     0.1000    0.0023
     8        0.0188             nan     0.1000    0.0017
     9        0.0166             nan     0.1000    0.0000
    10        0.0149             nan     0.1000    0.0009
    20        0.0080             nan     0.1000    0.0007
    40        0.0024             nan     0.1000   -0.0002
    60        0.0010             nan     0.1000    0.0000
    80        0.0003             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold21: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold21: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0395             nan     0.1000    0.0006
     2        0.0349             nan     0.1000    0.0053
     3        0.0306             nan     0.1000    0.0006
     4        0.0269             nan     0.1000    0.0021
     5        0.0244             nan     0.1000    0.0013
     6        0.0214             nan     0.1000    0.0027
     7        0.0187             nan     0.1000    0.0008
     8        0.0173             nan     0.1000    0.0012
     9        0.0151             nan     0.1000    0.0013
    10        0.0138             nan     0.1000    0.0016
    20        0.0054             nan     0.1000    0.0004
    40        0.0017             nan     0.1000   -0.0000
    60        0.0007             nan     0.1000    0.0000
    80        0.0003             nan     0.1000   -0.0000
   100        0.0002             nan     0.1000    0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000    0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold21: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold21: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0366             nan     0.1000    0.0044
     2        0.0325             nan     0.1000    0.0035
     3        0.0289             nan     0.1000    0.0029
     4        0.0273             nan     0.1000    0.0004
     5        0.0236             nan     0.1000    0.0011
     6        0.0210             nan     0.1000    0.0020
     7        0.0184             nan     0.1000    0.0018
     8        0.0170             nan     0.1000    0.0011
     9        0.0149             nan     0.1000    0.0016
    10        0.0143             nan     0.1000   -0.0004
    20        0.0081             nan     0.1000   -0.0000
    40        0.0037             nan     0.1000   -0.0002
    60        0.0019             nan     0.1000   -0.0000
    80        0.0010             nan     0.1000   -0.0001
   100        0.0005             nan     0.1000   -0.0000
   120        0.0003             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000    0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000    0.0000

- Fold21: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold21: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0357             nan     0.1000    0.0055
     2        0.0300             nan     0.1000    0.0044
     3        0.0255             nan     0.1000    0.0041
     4        0.0235             nan     0.1000    0.0013
     5        0.0225             nan     0.1000   -0.0003
     6        0.0191             nan     0.1000    0.0011
     7        0.0167             nan     0.1000    0.0007
     8        0.0152             nan     0.1000   -0.0000
     9        0.0133             nan     0.1000    0.0018
    10        0.0122             nan     0.1000    0.0000
    20        0.0048             nan     0.1000    0.0001
    40        0.0007             nan     0.1000    0.0000
    60        0.0002             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold21: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold21: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0363             nan     0.1000    0.0027
     2        0.0318             nan     0.1000    0.0044
     3        0.0274             nan     0.1000    0.0013
     4        0.0247             nan     0.1000    0.0022
     5        0.0224             nan     0.1000    0.0013
     6        0.0187             nan     0.1000    0.0020
     7        0.0175             nan     0.1000    0.0003
     8        0.0151             nan     0.1000    0.0011
     9        0.0126             nan     0.1000    0.0013
    10        0.0114             nan     0.1000   -0.0000
    20        0.0049             nan     0.1000   -0.0000
    40        0.0015             nan     0.1000   -0.0001
    60        0.0007             nan     0.1000    0.0000
    80        0.0003             nan     0.1000   -0.0000
   100        0.0002             nan     0.1000   -0.0000
   120        0.0001             nan     0.1000    0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold21: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold21: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0373             nan     0.1000    0.0038
     2        0.0325             nan     0.1000    0.0039
     3        0.0277             nan     0.1000    0.0036
     4        0.0255             nan     0.1000    0.0013
     5        0.0227             nan     0.1000    0.0006
     6        0.0199             nan     0.1000    0.0019
     7        0.0178             nan     0.1000    0.0017
     8        0.0158             nan     0.1000    0.0016
     9        0.0141             nan     0.1000    0.0015
    10        0.0125             nan     0.1000    0.0006
    20        0.0063             nan     0.1000   -0.0000
    40        0.0033             nan     0.1000   -0.0001
    60        0.0014             nan     0.1000   -0.0001
    80        0.0007             nan     0.1000   -0.0000
   100        0.0004             nan     0.1000    0.0000
   120        0.0002             nan     0.1000    0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000    0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold21: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold21: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0360             nan     0.1000    0.0035
     2        0.0301             nan     0.1000    0.0034
     3        0.0251             nan     0.1000    0.0041
     4        0.0208             nan     0.1000    0.0039
     5        0.0178             nan     0.1000    0.0027
     6        0.0168             nan     0.1000   -0.0007
     7        0.0146             nan     0.1000    0.0009
     8        0.0134             nan     0.1000    0.0006
     9        0.0125             nan     0.1000   -0.0001
    10        0.0108             nan     0.1000    0.0007
    20        0.0031             nan     0.1000    0.0001
    40        0.0005             nan     0.1000   -0.0000
    60        0.0001             nan     0.1000   -0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold21: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold21: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0359             nan     0.1000    0.0023
     2        0.0306             nan     0.1000    0.0062
     3        0.0258             nan     0.1000    0.0027
     4        0.0217             nan     0.1000    0.0029
     5        0.0193             nan     0.1000    0.0019
     6        0.0169             nan     0.1000    0.0015
     7        0.0142             nan     0.1000    0.0013
     8        0.0127             nan     0.1000    0.0006
     9        0.0129             nan     0.1000   -0.0012
    10        0.0113             nan     0.1000    0.0016
    20        0.0043             nan     0.1000    0.0002
    40        0.0011             nan     0.1000    0.0000
    60        0.0005             nan     0.1000    0.0000
    80        0.0002             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold21: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold21: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0357             nan     0.1000    0.0046
     2        0.0328             nan     0.1000    0.0019
     3        0.0304             nan     0.1000    0.0025
     4        0.0268             nan     0.1000    0.0032
     5        0.0243             nan     0.1000    0.0012
     6        0.0235             nan     0.1000    0.0002
     7        0.0213             nan     0.1000    0.0024
     8        0.0196             nan     0.1000    0.0014
     9        0.0181             nan     0.1000    0.0006
    10        0.0169             nan     0.1000    0.0012
    20        0.0071             nan     0.1000    0.0003
    40        0.0028             nan     0.1000   -0.0000
    60        0.0013             nan     0.1000    0.0000
    80        0.0007             nan     0.1000   -0.0000
   100        0.0004             nan     0.1000    0.0000
   120        0.0002             nan     0.1000    0.0000
   140        0.0001             nan     0.1000    0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold21: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold22: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0414             nan     0.0100    0.0002
     2        0.0409             nan     0.0100    0.0004
     3        0.0404             nan     0.0100    0.0005
     4        0.0399             nan     0.0100    0.0004
     5        0.0395             nan     0.0100    0.0003
     6        0.0390             nan     0.0100    0.0005
     7        0.0386             nan     0.0100    0.0002
     8        0.0380             nan     0.0100    0.0005
     9        0.0374             nan     0.0100    0.0005
    10        0.0369             nan     0.0100    0.0004
    20        0.0330             nan     0.0100    0.0002
    40        0.0273             nan     0.0100    0.0002
    60        0.0222             nan     0.0100    0.0000
    80        0.0183             nan     0.0100   -0.0000
   100        0.0147             nan     0.0100    0.0001
   120        0.0123             nan     0.0100    0.0001
   140        0.0105             nan     0.0100    0.0001
   160        0.0089             nan     0.0100    0.0000
   180        0.0075             nan     0.0100    0.0000
   200        0.0063             nan     0.0100    0.0001

- Fold22: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold22: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0412             nan     0.0100    0.0006
     2        0.0407             nan     0.0100    0.0003
     3        0.0401             nan     0.0100    0.0005
     4        0.0397             nan     0.0100    0.0004
     5        0.0392             nan     0.0100    0.0004
     6        0.0389             nan     0.0100    0.0001
     7        0.0383             nan     0.0100    0.0005
     8        0.0378             nan     0.0100    0.0005
     9        0.0374             nan     0.0100    0.0002
    10        0.0368             nan     0.0100    0.0003
    20        0.0331             nan     0.0100    0.0003
    40        0.0262             nan     0.0100    0.0003
    60        0.0213             nan     0.0100    0.0001
    80        0.0176             nan     0.0100    0.0000
   100        0.0147             nan     0.0100    0.0001
   120        0.0123             nan     0.0100    0.0001
   140        0.0104             nan     0.0100    0.0000
   160        0.0090             nan     0.0100    0.0000
   180        0.0078             nan     0.0100   -0.0000
   200        0.0068             nan     0.0100    0.0000

- Fold22: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold22: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0411             nan     0.0100    0.0005
     2        0.0405             nan     0.0100    0.0005
     3        0.0400             nan     0.0100    0.0004
     4        0.0395             nan     0.0100    0.0003
     5        0.0392             nan     0.0100    0.0001
     6        0.0386             nan     0.0100    0.0005
     7        0.0381             nan     0.0100    0.0003
     8        0.0376             nan     0.0100    0.0005
     9        0.0372             nan     0.0100    0.0001
    10        0.0367             nan     0.0100    0.0005
    20        0.0332             nan     0.0100   -0.0002
    40        0.0266             nan     0.0100    0.0003
    60        0.0218             nan     0.0100    0.0003
    80        0.0180             nan     0.0100   -0.0001
   100        0.0153             nan     0.0100    0.0001
   120        0.0131             nan     0.0100    0.0000
   140        0.0114             nan     0.0100    0.0001
   160        0.0098             nan     0.0100    0.0001
   180        0.0088             nan     0.0100    0.0000
   200        0.0079             nan     0.0100    0.0000

- Fold22: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold22: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0411             nan     0.0100    0.0005
     2        0.0406             nan     0.0100    0.0004
     3        0.0399             nan     0.0100    0.0007
     4        0.0395             nan     0.0100    0.0005
     5        0.0389             nan     0.0100    0.0002
     6        0.0383             nan     0.0100    0.0002
     7        0.0381             nan     0.0100    0.0000
     8        0.0375             nan     0.0100    0.0004
     9        0.0370             nan     0.0100    0.0001
    10        0.0363             nan     0.0100    0.0006
    20        0.0318             nan     0.0100    0.0002
    40        0.0241             nan     0.0100    0.0002
    60        0.0184             nan     0.0100   -0.0001
    80        0.0145             nan     0.0100    0.0000
   100        0.0116             nan     0.0100    0.0000
   120        0.0093             nan     0.0100    0.0000
   140        0.0076             nan     0.0100    0.0001
   160        0.0062             nan     0.0100    0.0000
   180        0.0050             nan     0.0100   -0.0000
   200        0.0042             nan     0.0100    0.0000

- Fold22: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold22: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0411             nan     0.0100    0.0003
     2        0.0406             nan     0.0100    0.0002
     3        0.0399             nan     0.0100    0.0007
     4        0.0393             nan     0.0100    0.0004
     5        0.0388             nan     0.0100    0.0004
     6        0.0385             nan     0.0100    0.0002
     7        0.0379             nan     0.0100    0.0004
     8        0.0374             nan     0.0100    0.0003
     9        0.0370             nan     0.0100    0.0003
    10        0.0365             nan     0.0100    0.0005
    20        0.0323             nan     0.0100    0.0004
    40        0.0244             nan     0.0100    0.0002
    60        0.0189             nan     0.0100    0.0002
    80        0.0149             nan     0.0100    0.0001
   100        0.0121             nan     0.0100    0.0001
   120        0.0097             nan     0.0100    0.0001
   140        0.0078             nan     0.0100   -0.0000
   160        0.0066             nan     0.0100   -0.0000
   180        0.0055             nan     0.0100   -0.0000
   200        0.0047             nan     0.0100   -0.0000

- Fold22: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold22: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0414             nan     0.0100    0.0001
     2        0.0408             nan     0.0100    0.0005
     3        0.0402             nan     0.0100    0.0006
     4        0.0398             nan     0.0100    0.0003
     5        0.0394             nan     0.0100    0.0002
     6        0.0388             nan     0.0100    0.0002
     7        0.0384             nan     0.0100    0.0003
     8        0.0380             nan     0.0100    0.0004
     9        0.0374             nan     0.0100    0.0004
    10        0.0368             nan     0.0100    0.0003
    20        0.0328             nan     0.0100    0.0004
    40        0.0264             nan     0.0100    0.0001
    60        0.0219             nan     0.0100    0.0002
    80        0.0180             nan     0.0100    0.0001
   100        0.0156             nan     0.0100    0.0000
   120        0.0131             nan     0.0100    0.0000
   140        0.0115             nan     0.0100    0.0001
   160        0.0101             nan     0.0100    0.0000
   180        0.0089             nan     0.0100    0.0001
   200        0.0079             nan     0.0100    0.0000

- Fold22: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold22: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0413             nan     0.0100    0.0002
     2        0.0405             nan     0.0100    0.0006
     3        0.0398             nan     0.0100    0.0005
     4        0.0392             nan     0.0100    0.0006
     5        0.0385             nan     0.0100    0.0006
     6        0.0380             nan     0.0100    0.0003
     7        0.0373             nan     0.0100    0.0004
     8        0.0370             nan     0.0100    0.0002
     9        0.0366             nan     0.0100    0.0001
    10        0.0362             nan     0.0100    0.0003
    20        0.0310             nan     0.0100    0.0002
    40        0.0235             nan     0.0100    0.0002
    60        0.0176             nan     0.0100    0.0003
    80        0.0137             nan     0.0100    0.0001
   100        0.0108             nan     0.0100    0.0001
   120        0.0085             nan     0.0100    0.0000
   140        0.0067             nan     0.0100    0.0000
   160        0.0053             nan     0.0100    0.0000
   180        0.0042             nan     0.0100    0.0000
   200        0.0034             nan     0.0100   -0.0000

- Fold22: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold22: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0412             nan     0.0100    0.0005
     2        0.0406             nan     0.0100    0.0006
     3        0.0400             nan     0.0100    0.0005
     4        0.0395             nan     0.0100    0.0004
     5        0.0390             nan     0.0100    0.0002
     6        0.0386             nan     0.0100    0.0002
     7        0.0379             nan     0.0100    0.0007
     8        0.0374             nan     0.0100    0.0004
     9        0.0370             nan     0.0100    0.0002
    10        0.0365             nan     0.0100    0.0004
    20        0.0319             nan     0.0100    0.0003
    40        0.0245             nan     0.0100    0.0004
    60        0.0192             nan     0.0100    0.0002
    80        0.0154             nan     0.0100    0.0001
   100        0.0120             nan     0.0100    0.0000
   120        0.0094             nan     0.0100    0.0001
   140        0.0076             nan     0.0100    0.0000
   160        0.0064             nan     0.0100    0.0000
   180        0.0052             nan     0.0100    0.0000
   200        0.0043             nan     0.0100   -0.0000

- Fold22: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold22: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0411             nan     0.0100    0.0006
     2        0.0406             nan     0.0100    0.0002
     3        0.0400             nan     0.0100    0.0005
     4        0.0395             nan     0.0100    0.0005
     5        0.0391             nan     0.0100    0.0004
     6        0.0387             nan     0.0100    0.0003
     7        0.0381             nan     0.0100    0.0005
     8        0.0377             nan     0.0100    0.0003
     9        0.0374             nan     0.0100    0.0002
    10        0.0371             nan     0.0100    0.0004
    20        0.0331             nan     0.0100    0.0000
    40        0.0267             nan     0.0100    0.0001
    60        0.0216             nan     0.0100    0.0002
    80        0.0183             nan     0.0100    0.0001
   100        0.0156             nan     0.0100    0.0001
   120        0.0136             nan     0.0100    0.0001
   140        0.0119             nan     0.0100    0.0000
   160        0.0101             nan     0.0100    0.0001
   180        0.0090             nan     0.0100    0.0000
   200        0.0080             nan     0.0100   -0.0000

- Fold22: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold22: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0389             nan     0.0500    0.0027
     2        0.0366             nan     0.0500    0.0023
     3        0.0364             nan     0.0500   -0.0003
     4        0.0338             nan     0.0500    0.0012
     5        0.0321             nan     0.0500    0.0015
     6        0.0307             nan     0.0500    0.0007
     7        0.0286             nan     0.0500    0.0021
     8        0.0269             nan     0.0500    0.0013
     9        0.0256             nan     0.0500    0.0014
    10        0.0242             nan     0.0500    0.0013
    20        0.0159             nan     0.0500    0.0004
    40        0.0067             nan     0.0500    0.0000
    60        0.0030             nan     0.0500   -0.0000
    80        0.0017             nan     0.0500   -0.0000
   100        0.0010             nan     0.0500    0.0000
   120        0.0006             nan     0.0500    0.0000
   140        0.0004             nan     0.0500   -0.0000
   160        0.0003             nan     0.0500   -0.0000
   180        0.0002             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold22: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold22: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0388             nan     0.0500    0.0027
     2        0.0360             nan     0.0500    0.0022
     3        0.0335             nan     0.0500    0.0022
     4        0.0316             nan     0.0500    0.0017
     5        0.0296             nan     0.0500    0.0018
     6        0.0277             nan     0.0500    0.0019
     7        0.0264             nan     0.0500    0.0014
     8        0.0253             nan     0.0500    0.0003
     9        0.0236             nan     0.0500    0.0011
    10        0.0224             nan     0.0500    0.0007
    20        0.0137             nan     0.0500   -0.0008
    40        0.0053             nan     0.0500   -0.0001
    60        0.0027             nan     0.0500    0.0001
    80        0.0015             nan     0.0500    0.0000
   100        0.0010             nan     0.0500   -0.0000
   120        0.0006             nan     0.0500   -0.0000
   140        0.0004             nan     0.0500   -0.0000
   160        0.0003             nan     0.0500   -0.0000
   180        0.0002             nan     0.0500    0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold22: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold22: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0409             nan     0.0500   -0.0015
     2        0.0391             nan     0.0500    0.0008
     3        0.0374             nan     0.0500    0.0009
     4        0.0351             nan     0.0500    0.0021
     5        0.0330             nan     0.0500    0.0023
     6        0.0313             nan     0.0500    0.0009
     7        0.0295             nan     0.0500    0.0013
     8        0.0286             nan     0.0500    0.0002
     9        0.0278             nan     0.0500    0.0004
    10        0.0271             nan     0.0500    0.0001
    20        0.0179             nan     0.0500    0.0002
    40        0.0089             nan     0.0500    0.0001
    60        0.0058             nan     0.0500    0.0002
    80        0.0038             nan     0.0500    0.0000
   100        0.0025             nan     0.0500   -0.0000
   120        0.0017             nan     0.0500    0.0000
   140        0.0012             nan     0.0500   -0.0000
   160        0.0009             nan     0.0500   -0.0000
   180        0.0006             nan     0.0500    0.0000
   200        0.0005             nan     0.0500   -0.0000

- Fold22: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold22: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0385             nan     0.0500    0.0027
     2        0.0363             nan     0.0500    0.0020
     3        0.0335             nan     0.0500    0.0025
     4        0.0314             nan     0.0500    0.0018
     5        0.0294             nan     0.0500    0.0014
     6        0.0283             nan     0.0500    0.0007
     7        0.0266             nan     0.0500    0.0014
     8        0.0251             nan     0.0500    0.0012
     9        0.0235             nan     0.0500    0.0013
    10        0.0220             nan     0.0500    0.0011
    20        0.0125             nan     0.0500   -0.0005
    40        0.0035             nan     0.0500    0.0000
    60        0.0015             nan     0.0500   -0.0000
    80        0.0007             nan     0.0500   -0.0000
   100        0.0003             nan     0.0500   -0.0000
   120        0.0002             nan     0.0500    0.0000
   140        0.0001             nan     0.0500   -0.0000
   160        0.0001             nan     0.0500    0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold22: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold22: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0385             nan     0.0500    0.0026
     2        0.0363             nan     0.0500    0.0026
     3        0.0344             nan     0.0500    0.0012
     4        0.0321             nan     0.0500    0.0026
     5        0.0294             nan     0.0500    0.0018
     6        0.0276             nan     0.0500    0.0015
     7        0.0254             nan     0.0500    0.0013
     8        0.0233             nan     0.0500    0.0007
     9        0.0215             nan     0.0500    0.0009
    10        0.0207             nan     0.0500    0.0004
    20        0.0121             nan     0.0500    0.0005
    40        0.0048             nan     0.0500    0.0000
    60        0.0023             nan     0.0500   -0.0000
    80        0.0013             nan     0.0500    0.0000
   100        0.0008             nan     0.0500   -0.0000
   120        0.0004             nan     0.0500    0.0000
   140        0.0002             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500    0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold22: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold22: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0386             nan     0.0500    0.0025
     2        0.0361             nan     0.0500    0.0023
     3        0.0334             nan     0.0500    0.0024
     4        0.0318             nan     0.0500    0.0016
     5        0.0301             nan     0.0500    0.0005
     6        0.0289             nan     0.0500    0.0013
     7        0.0276             nan     0.0500    0.0010
     8        0.0265             nan     0.0500    0.0006
     9        0.0260             nan     0.0500    0.0002
    10        0.0243             nan     0.0500    0.0011
    20        0.0173             nan     0.0500    0.0004
    40        0.0105             nan     0.0500    0.0004
    60        0.0060             nan     0.0500    0.0001
    80        0.0041             nan     0.0500    0.0000
   100        0.0031             nan     0.0500    0.0000
   120        0.0023             nan     0.0500    0.0000
   140        0.0016             nan     0.0500   -0.0000
   160        0.0013             nan     0.0500   -0.0000
   180        0.0011             nan     0.0500   -0.0000
   200        0.0008             nan     0.0500    0.0000

- Fold22: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold22: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0396             nan     0.0500    0.0001
     2        0.0375             nan     0.0500    0.0013
     3        0.0346             nan     0.0500    0.0024
     4        0.0314             nan     0.0500    0.0022
     5        0.0292             nan     0.0500    0.0022
     6        0.0270             nan     0.0500    0.0019
     7        0.0252             nan     0.0500    0.0008
     8        0.0233             nan     0.0500    0.0019
     9        0.0218             nan     0.0500    0.0011
    10        0.0204             nan     0.0500    0.0007
    20        0.0109             nan     0.0500    0.0006
    40        0.0033             nan     0.0500   -0.0000
    60        0.0012             nan     0.0500    0.0001
    80        0.0006             nan     0.0500   -0.0000
   100        0.0003             nan     0.0500    0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0001             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500    0.0000

- Fold22: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold22: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0389             nan     0.0500    0.0027
     2        0.0362             nan     0.0500    0.0017
     3        0.0342             nan     0.0500    0.0020
     4        0.0327             nan     0.0500    0.0013
     5        0.0299             nan     0.0500    0.0018
     6        0.0281             nan     0.0500    0.0014
     7        0.0257             nan     0.0500    0.0022
     8        0.0243             nan     0.0500    0.0010
     9        0.0229             nan     0.0500    0.0010
    10        0.0216             nan     0.0500    0.0009
    20        0.0119             nan     0.0500    0.0002
    40        0.0045             nan     0.0500   -0.0000
    60        0.0019             nan     0.0500   -0.0000
    80        0.0010             nan     0.0500    0.0000
   100        0.0006             nan     0.0500    0.0000
   120        0.0003             nan     0.0500   -0.0000
   140        0.0002             nan     0.0500   -0.0000
   160        0.0001             nan     0.0500    0.0000
   180        0.0001             nan     0.0500    0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold22: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold22: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0395             nan     0.0500   -0.0001
     2        0.0370             nan     0.0500    0.0018
     3        0.0347             nan     0.0500    0.0019
     4        0.0328             nan     0.0500    0.0021
     5        0.0307             nan     0.0500    0.0021
     6        0.0285             nan     0.0500    0.0017
     7        0.0264             nan     0.0500    0.0017
     8        0.0251             nan     0.0500   -0.0005
     9        0.0242             nan     0.0500    0.0012
    10        0.0225             nan     0.0500    0.0013
    20        0.0145             nan     0.0500    0.0005
    40        0.0073             nan     0.0500   -0.0001
    60        0.0045             nan     0.0500    0.0000
    80        0.0030             nan     0.0500   -0.0001
   100        0.0020             nan     0.0500   -0.0000
   120        0.0013             nan     0.0500   -0.0000
   140        0.0010             nan     0.0500   -0.0000
   160        0.0008             nan     0.0500   -0.0000
   180        0.0006             nan     0.0500   -0.0000
   200        0.0004             nan     0.0500    0.0000

- Fold22: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold22: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0364             nan     0.1000    0.0048
     2        0.0345             nan     0.1000   -0.0011
     3        0.0312             nan     0.1000    0.0026
     4        0.0289             nan     0.1000    0.0000
     5        0.0262             nan     0.1000    0.0013
     6        0.0242             nan     0.1000    0.0003
     7        0.0218             nan     0.1000    0.0017
     8        0.0201             nan     0.1000    0.0010
     9        0.0177             nan     0.1000    0.0022
    10        0.0163             nan     0.1000    0.0007
    20        0.0064             nan     0.1000   -0.0000
    40        0.0019             nan     0.1000    0.0001
    60        0.0006             nan     0.1000   -0.0000
    80        0.0002             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000    0.0000
   120        0.0000             nan     0.1000    0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold22: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold22: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0363             nan     0.1000    0.0023
     2        0.0319             nan     0.1000    0.0041
     3        0.0288             nan     0.1000    0.0025
     4        0.0277             nan     0.1000    0.0000
     5        0.0240             nan     0.1000    0.0026
     6        0.0209             nan     0.1000    0.0022
     7        0.0185             nan     0.1000    0.0012
     8        0.0178             nan     0.1000   -0.0003
     9        0.0169             nan     0.1000    0.0001
    10        0.0151             nan     0.1000    0.0001
    20        0.0073             nan     0.1000    0.0001
    40        0.0023             nan     0.1000   -0.0000
    60        0.0008             nan     0.1000   -0.0000
    80        0.0004             nan     0.1000   -0.0000
   100        0.0002             nan     0.1000   -0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold22: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold22: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0366             nan     0.1000    0.0050
     2        0.0332             nan     0.1000    0.0027
     3        0.0299             nan     0.1000    0.0037
     4        0.0269             nan     0.1000    0.0034
     5        0.0241             nan     0.1000    0.0029
     6        0.0220             nan     0.1000    0.0010
     7        0.0198             nan     0.1000   -0.0003
     8        0.0178             nan     0.1000    0.0013
     9        0.0168             nan     0.1000    0.0002
    10        0.0148             nan     0.1000    0.0010
    20        0.0075             nan     0.1000    0.0001
    40        0.0022             nan     0.1000    0.0000
    60        0.0010             nan     0.1000   -0.0001
    80        0.0005             nan     0.1000    0.0000
   100        0.0003             nan     0.1000   -0.0000
   120        0.0002             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000    0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000    0.0000
   200        0.0000             nan     0.1000    0.0000

- Fold22: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold22: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0338             nan     0.1000    0.0084
     2        0.0277             nan     0.1000    0.0038
     3        0.0245             nan     0.1000    0.0010
     4        0.0211             nan     0.1000    0.0037
     5        0.0193             nan     0.1000    0.0010
     6        0.0165             nan     0.1000    0.0015
     7        0.0139             nan     0.1000    0.0026
     8        0.0127             nan     0.1000    0.0011
     9        0.0114             nan     0.1000    0.0012
    10        0.0101             nan     0.1000    0.0009
    20        0.0040             nan     0.1000    0.0003
    40        0.0007             nan     0.1000    0.0000
    60        0.0003             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000    0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000    0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold22: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold22: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0366             nan     0.1000    0.0044
     2        0.0315             nan     0.1000    0.0043
     3        0.0259             nan     0.1000    0.0034
     4        0.0238             nan     0.1000    0.0010
     5        0.0215             nan     0.1000   -0.0002
     6        0.0188             nan     0.1000   -0.0000
     7        0.0157             nan     0.1000    0.0017
     8        0.0135             nan     0.1000    0.0016
     9        0.0131             nan     0.1000    0.0003
    10        0.0121             nan     0.1000   -0.0001
    20        0.0041             nan     0.1000    0.0001
    40        0.0009             nan     0.1000    0.0000
    60        0.0004             nan     0.1000   -0.0000
    80        0.0002             nan     0.1000    0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0001             nan     0.1000    0.0000
   140        0.0000             nan     0.1000    0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold22: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold22: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0365             nan     0.1000    0.0049
     2        0.0328             nan     0.1000    0.0028
     3        0.0295             nan     0.1000    0.0016
     4        0.0262             nan     0.1000    0.0034
     5        0.0235             nan     0.1000    0.0024
     6        0.0225             nan     0.1000   -0.0005
     7        0.0203             nan     0.1000    0.0016
     8        0.0182             nan     0.1000    0.0014
     9        0.0163             nan     0.1000    0.0001
    10        0.0154             nan     0.1000   -0.0003
    20        0.0076             nan     0.1000    0.0003
    40        0.0033             nan     0.1000   -0.0001
    60        0.0014             nan     0.1000   -0.0001
    80        0.0008             nan     0.1000    0.0000
   100        0.0004             nan     0.1000   -0.0000
   120        0.0002             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold22: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold22: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0364             nan     0.1000    0.0029
     2        0.0321             nan     0.1000    0.0031
     3        0.0262             nan     0.1000    0.0051
     4        0.0239             nan     0.1000   -0.0001
     5        0.0199             nan     0.1000    0.0023
     6        0.0171             nan     0.1000    0.0018
     7        0.0146             nan     0.1000    0.0011
     8        0.0128             nan     0.1000    0.0004
     9        0.0113             nan     0.1000    0.0009
    10        0.0098             nan     0.1000    0.0015
    20        0.0033             nan     0.1000   -0.0002
    40        0.0006             nan     0.1000   -0.0000
    60        0.0001             nan     0.1000   -0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold22: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold22: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0347             nan     0.1000    0.0057
     2        0.0295             nan     0.1000    0.0044
     3        0.0262             nan     0.1000    0.0029
     4        0.0241             nan     0.1000    0.0024
     5        0.0216             nan     0.1000    0.0019
     6        0.0196             nan     0.1000    0.0008
     7        0.0169             nan     0.1000    0.0005
     8        0.0156             nan     0.1000    0.0009
     9        0.0137             nan     0.1000    0.0010
    10        0.0126             nan     0.1000    0.0002
    20        0.0043             nan     0.1000    0.0003
    40        0.0014             nan     0.1000   -0.0001
    60        0.0005             nan     0.1000    0.0000
    80        0.0002             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold22: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold22: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0382             nan     0.1000    0.0007
     2        0.0347             nan     0.1000    0.0024
     3        0.0332             nan     0.1000   -0.0012
     4        0.0298             nan     0.1000    0.0033
     5        0.0260             nan     0.1000    0.0024
     6        0.0226             nan     0.1000    0.0028
     7        0.0201             nan     0.1000    0.0018
     8        0.0189             nan     0.1000    0.0008
     9        0.0173             nan     0.1000    0.0009
    10        0.0158             nan     0.1000    0.0012
    20        0.0098             nan     0.1000    0.0003
    40        0.0037             nan     0.1000   -0.0001
    60        0.0016             nan     0.1000    0.0000
    80        0.0009             nan     0.1000    0.0000
   100        0.0006             nan     0.1000    0.0000
   120        0.0004             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000    0.0000
   160        0.0002             nan     0.1000    0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000    0.0000

- Fold22: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold23: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0436             nan     0.0100    0.0005
     2        0.0431             nan     0.0100    0.0004
     3        0.0428             nan     0.0100    0.0001
     4        0.0423             nan     0.0100    0.0003
     5        0.0416             nan     0.0100    0.0005
     6        0.0413             nan     0.0100    0.0003
     7        0.0408             nan     0.0100    0.0005
     8        0.0404             nan     0.0100    0.0005
     9        0.0399             nan     0.0100    0.0005
    10        0.0393             nan     0.0100    0.0005
    20        0.0348             nan     0.0100    0.0004
    40        0.0276             nan     0.0100    0.0004
    60        0.0222             nan     0.0100   -0.0001
    80        0.0183             nan     0.0100    0.0001
   100        0.0149             nan     0.0100    0.0002
   120        0.0125             nan     0.0100    0.0001
   140        0.0102             nan     0.0100    0.0000
   160        0.0086             nan     0.0100    0.0000
   180        0.0071             nan     0.0100    0.0000
   200        0.0060             nan     0.0100    0.0000

- Fold23: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold23: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0436             nan     0.0100    0.0006
     2        0.0431             nan     0.0100    0.0006
     3        0.0425             nan     0.0100    0.0005
     4        0.0419             nan     0.0100    0.0006
     5        0.0414             nan     0.0100    0.0004
     6        0.0409             nan     0.0100    0.0005
     7        0.0403             nan     0.0100    0.0005
     8        0.0398             nan     0.0100    0.0005
     9        0.0393             nan     0.0100    0.0004
    10        0.0388             nan     0.0100    0.0003
    20        0.0342             nan     0.0100    0.0004
    40        0.0274             nan     0.0100    0.0003
    60        0.0218             nan     0.0100    0.0001
    80        0.0175             nan     0.0100    0.0001
   100        0.0143             nan     0.0100    0.0001
   120        0.0121             nan     0.0100    0.0001
   140        0.0098             nan     0.0100    0.0001
   160        0.0082             nan     0.0100    0.0001
   180        0.0069             nan     0.0100    0.0001
   200        0.0059             nan     0.0100    0.0000

- Fold23: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold23: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0434             nan     0.0100    0.0005
     2        0.0427             nan     0.0100    0.0005
     3        0.0421             nan     0.0100    0.0006
     4        0.0415             nan     0.0100    0.0003
     5        0.0409             nan     0.0100    0.0005
     6        0.0405             nan     0.0100    0.0004
     7        0.0401             nan     0.0100    0.0003
     8        0.0398             nan     0.0100    0.0002
     9        0.0392             nan     0.0100    0.0006
    10        0.0388             nan     0.0100    0.0004
    20        0.0341             nan     0.0100    0.0004
    40        0.0272             nan     0.0100    0.0002
    60        0.0225             nan     0.0100    0.0001
    80        0.0186             nan     0.0100    0.0002
   100        0.0157             nan     0.0100    0.0001
   120        0.0130             nan     0.0100   -0.0000
   140        0.0112             nan     0.0100    0.0000
   160        0.0097             nan     0.0100    0.0000
   180        0.0085             nan     0.0100    0.0000
   200        0.0075             nan     0.0100    0.0000

- Fold23: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold23: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0436             nan     0.0100    0.0001
     2        0.0431             nan     0.0100    0.0005
     3        0.0427             nan     0.0100    0.0004
     4        0.0420             nan     0.0100    0.0005
     5        0.0413             nan     0.0100    0.0005
     6        0.0407             nan     0.0100    0.0005
     7        0.0402             nan     0.0100    0.0005
     8        0.0395             nan     0.0100    0.0005
     9        0.0388             nan     0.0100    0.0005
    10        0.0381             nan     0.0100    0.0004
    20        0.0333             nan     0.0100    0.0006
    40        0.0254             nan     0.0100    0.0002
    60        0.0197             nan     0.0100    0.0002
    80        0.0154             nan     0.0100    0.0002
   100        0.0117             nan     0.0100    0.0001
   120        0.0094             nan     0.0100    0.0000
   140        0.0073             nan     0.0100    0.0000
   160        0.0058             nan     0.0100    0.0000
   180        0.0047             nan     0.0100    0.0000
   200        0.0038             nan     0.0100    0.0000

- Fold23: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold23: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0434             nan     0.0100    0.0005
     2        0.0426             nan     0.0100    0.0007
     3        0.0421             nan     0.0100    0.0005
     4        0.0418             nan     0.0100    0.0003
     5        0.0414             nan     0.0100    0.0002
     6        0.0410             nan     0.0100    0.0005
     7        0.0404             nan     0.0100    0.0005
     8        0.0398             nan     0.0100    0.0005
     9        0.0393             nan     0.0100    0.0006
    10        0.0387             nan     0.0100    0.0005
    20        0.0337             nan     0.0100    0.0004
    40        0.0260             nan     0.0100    0.0001
    60        0.0199             nan     0.0100    0.0002
    80        0.0154             nan     0.0100    0.0002
   100        0.0121             nan     0.0100    0.0001
   120        0.0097             nan     0.0100    0.0001
   140        0.0078             nan     0.0100    0.0000
   160        0.0065             nan     0.0100    0.0001
   180        0.0052             nan     0.0100    0.0000
   200        0.0044             nan     0.0100    0.0000

- Fold23: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold23: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0436             nan     0.0100    0.0002
     2        0.0430             nan     0.0100    0.0006
     3        0.0425             nan     0.0100    0.0005
     4        0.0421             nan     0.0100    0.0003
     5        0.0416             nan     0.0100    0.0004
     6        0.0410             nan     0.0100    0.0005
     7        0.0406             nan     0.0100    0.0004
     8        0.0401             nan     0.0100    0.0005
     9        0.0397             nan     0.0100    0.0002
    10        0.0392             nan     0.0100    0.0003
    20        0.0346             nan     0.0100   -0.0000
    40        0.0280             nan     0.0100    0.0003
    60        0.0231             nan     0.0100    0.0002
    80        0.0186             nan     0.0100    0.0000
   100        0.0157             nan     0.0100    0.0001
   120        0.0133             nan     0.0100    0.0000
   140        0.0114             nan     0.0100   -0.0000
   160        0.0098             nan     0.0100    0.0000
   180        0.0085             nan     0.0100    0.0000
   200        0.0074             nan     0.0100    0.0000

- Fold23: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold23: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0433             nan     0.0100    0.0006
     2        0.0427             nan     0.0100    0.0003
     3        0.0420             nan     0.0100    0.0005
     4        0.0415             nan     0.0100    0.0006
     5        0.0409             nan     0.0100    0.0003
     6        0.0404             nan     0.0100   -0.0001
     7        0.0397             nan     0.0100    0.0006
     8        0.0392             nan     0.0100   -0.0000
     9        0.0384             nan     0.0100    0.0006
    10        0.0379             nan     0.0100    0.0003
    20        0.0329             nan     0.0100    0.0006
    40        0.0247             nan     0.0100    0.0002
    60        0.0185             nan     0.0100    0.0001
    80        0.0144             nan     0.0100   -0.0001
   100        0.0111             nan     0.0100    0.0001
   120        0.0086             nan     0.0100   -0.0000
   140        0.0068             nan     0.0100    0.0000
   160        0.0054             nan     0.0100    0.0000
   180        0.0043             nan     0.0100   -0.0000
   200        0.0035             nan     0.0100   -0.0000

- Fold23: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold23: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0434             nan     0.0100    0.0005
     2        0.0430             nan     0.0100    0.0005
     3        0.0426             nan     0.0100    0.0004
     4        0.0420             nan     0.0100    0.0005
     5        0.0414             nan     0.0100    0.0004
     6        0.0411             nan     0.0100   -0.0003
     7        0.0406             nan     0.0100    0.0005
     8        0.0398             nan     0.0100    0.0005
     9        0.0393             nan     0.0100    0.0006
    10        0.0388             nan     0.0100    0.0005
    20        0.0345             nan     0.0100    0.0002
    40        0.0265             nan     0.0100    0.0004
    60        0.0209             nan     0.0100    0.0002
    80        0.0163             nan     0.0100    0.0002
   100        0.0127             nan     0.0100    0.0000
   120        0.0099             nan     0.0100   -0.0000
   140        0.0081             nan     0.0100    0.0000
   160        0.0066             nan     0.0100    0.0001
   180        0.0053             nan     0.0100    0.0000
   200        0.0044             nan     0.0100    0.0000

- Fold23: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold23: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0436             nan     0.0100    0.0003
     2        0.0431             nan     0.0100    0.0005
     3        0.0427             nan     0.0100    0.0001
     4        0.0423             nan     0.0100    0.0004
     5        0.0417             nan     0.0100    0.0004
     6        0.0411             nan     0.0100    0.0002
     7        0.0404             nan     0.0100    0.0005
     8        0.0399             nan     0.0100    0.0005
     9        0.0396             nan     0.0100    0.0003
    10        0.0391             nan     0.0100    0.0003
    20        0.0353             nan     0.0100    0.0003
    40        0.0282             nan     0.0100    0.0001
    60        0.0231             nan     0.0100    0.0001
    80        0.0191             nan     0.0100    0.0001
   100        0.0161             nan     0.0100    0.0001
   120        0.0135             nan     0.0100    0.0001
   140        0.0114             nan     0.0100    0.0001
   160        0.0100             nan     0.0100    0.0000
   180        0.0087             nan     0.0100    0.0000
   200        0.0077             nan     0.0100    0.0000

- Fold23: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold23: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0416             nan     0.0500    0.0029
     2        0.0383             nan     0.0500    0.0017
     3        0.0366             nan     0.0500    0.0014
     4        0.0342             nan     0.0500    0.0013
     5        0.0330             nan     0.0500    0.0010
     6        0.0313             nan     0.0500    0.0019
     7        0.0297             nan     0.0500    0.0007
     8        0.0283             nan     0.0500    0.0005
     9        0.0267             nan     0.0500    0.0014
    10        0.0253             nan     0.0500    0.0016
    20        0.0155             nan     0.0500    0.0001
    40        0.0064             nan     0.0500    0.0001
    60        0.0031             nan     0.0500    0.0000
    80        0.0016             nan     0.0500    0.0000
   100        0.0010             nan     0.0500   -0.0000
   120        0.0006             nan     0.0500    0.0000
   140        0.0003             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500    0.0000
   180        0.0001             nan     0.0500    0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold23: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold23: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0418             nan     0.0500    0.0020
     2        0.0402             nan     0.0500    0.0014
     3        0.0377             nan     0.0500    0.0024
     4        0.0361             nan     0.0500    0.0013
     5        0.0339             nan     0.0500    0.0015
     6        0.0326             nan     0.0500    0.0012
     7        0.0308             nan     0.0500    0.0020
     8        0.0289             nan     0.0500    0.0021
     9        0.0274             nan     0.0500    0.0016
    10        0.0259             nan     0.0500    0.0014
    20        0.0168             nan     0.0500   -0.0002
    40        0.0073             nan     0.0500    0.0004
    60        0.0038             nan     0.0500    0.0000
    80        0.0019             nan     0.0500    0.0000
   100        0.0009             nan     0.0500   -0.0000
   120        0.0006             nan     0.0500    0.0000
   140        0.0004             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold23: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold23: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0426             nan     0.0500   -0.0001
     2        0.0411             nan     0.0500    0.0006
     3        0.0389             nan     0.0500    0.0012
     4        0.0374             nan     0.0500    0.0016
     5        0.0349             nan     0.0500    0.0025
     6        0.0324             nan     0.0500    0.0012
     7        0.0311             nan     0.0500    0.0014
     8        0.0289             nan     0.0500    0.0016
     9        0.0271             nan     0.0500    0.0012
    10        0.0262             nan     0.0500    0.0002
    20        0.0167             nan     0.0500    0.0009
    40        0.0086             nan     0.0500    0.0002
    60        0.0054             nan     0.0500    0.0001
    80        0.0038             nan     0.0500   -0.0001
   100        0.0027             nan     0.0500   -0.0001
   120        0.0019             nan     0.0500   -0.0000
   140        0.0013             nan     0.0500   -0.0000
   160        0.0011             nan     0.0500   -0.0000
   180        0.0008             nan     0.0500   -0.0000
   200        0.0006             nan     0.0500    0.0000

- Fold23: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold23: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0401             nan     0.0500    0.0037
     2        0.0377             nan     0.0500    0.0019
     3        0.0341             nan     0.0500    0.0025
     4        0.0320             nan     0.0500    0.0011
     5        0.0298             nan     0.0500    0.0010
     6        0.0275             nan     0.0500    0.0020
     7        0.0256             nan     0.0500    0.0012
     8        0.0244             nan     0.0500    0.0003
     9        0.0220             nan     0.0500    0.0025
    10        0.0214             nan     0.0500    0.0001
    20        0.0111             nan     0.0500    0.0004
    40        0.0037             nan     0.0500    0.0000
    60        0.0012             nan     0.0500    0.0000
    80        0.0005             nan     0.0500    0.0000
   100        0.0003             nan     0.0500    0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0001             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500    0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold23: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold23: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0421             nan     0.0500    0.0003
     2        0.0401             nan     0.0500    0.0003
     3        0.0370             nan     0.0500    0.0011
     4        0.0351             nan     0.0500    0.0009
     5        0.0324             nan     0.0500    0.0023
     6        0.0302             nan     0.0500    0.0015
     7        0.0277             nan     0.0500    0.0015
     8        0.0254             nan     0.0500    0.0018
     9        0.0234             nan     0.0500    0.0012
    10        0.0216             nan     0.0500    0.0010
    20        0.0119             nan     0.0500   -0.0004
    40        0.0041             nan     0.0500    0.0002
    60        0.0020             nan     0.0500   -0.0000
    80        0.0011             nan     0.0500    0.0000
   100        0.0007             nan     0.0500   -0.0000
   120        0.0005             nan     0.0500    0.0000
   140        0.0003             nan     0.0500   -0.0000
   160        0.0003             nan     0.0500   -0.0000
   180        0.0002             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold23: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold23: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0417             nan     0.0500    0.0025
     2        0.0399             nan     0.0500    0.0009
     3        0.0381             nan     0.0500    0.0012
     4        0.0365             nan     0.0500    0.0006
     5        0.0347             nan     0.0500    0.0011
     6        0.0328             nan     0.0500    0.0016
     7        0.0311             nan     0.0500    0.0019
     8        0.0291             nan     0.0500    0.0014
     9        0.0273             nan     0.0500    0.0007
    10        0.0261             nan     0.0500    0.0009
    20        0.0164             nan     0.0500    0.0001
    40        0.0077             nan     0.0500    0.0002
    60        0.0046             nan     0.0500    0.0001
    80        0.0029             nan     0.0500   -0.0000
   100        0.0019             nan     0.0500   -0.0000
   120        0.0012             nan     0.0500   -0.0000
   140        0.0009             nan     0.0500   -0.0000
   160        0.0006             nan     0.0500   -0.0000
   180        0.0005             nan     0.0500    0.0000
   200        0.0003             nan     0.0500   -0.0000

- Fold23: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold23: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0408             nan     0.0500    0.0039
     2        0.0372             nan     0.0500    0.0035
     3        0.0346             nan     0.0500    0.0010
     4        0.0323             nan     0.0500    0.0011
     5        0.0295             nan     0.0500    0.0021
     6        0.0273             nan     0.0500    0.0010
     7        0.0259             nan     0.0500    0.0004
     8        0.0241             nan     0.0500    0.0011
     9        0.0230             nan     0.0500    0.0006
    10        0.0210             nan     0.0500    0.0015
    20        0.0111             nan     0.0500    0.0002
    40        0.0040             nan     0.0500    0.0001
    60        0.0014             nan     0.0500   -0.0001
    80        0.0005             nan     0.0500   -0.0000
   100        0.0002             nan     0.0500   -0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0000             nan     0.0500    0.0000
   160        0.0000             nan     0.0500    0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold23: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold23: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0413             nan     0.0500    0.0034
     2        0.0388             nan     0.0500    0.0023
     3        0.0362             nan     0.0500    0.0024
     4        0.0351             nan     0.0500    0.0003
     5        0.0320             nan     0.0500    0.0027
     6        0.0309             nan     0.0500    0.0007
     7        0.0286             nan     0.0500    0.0015
     8        0.0267             nan     0.0500    0.0018
     9        0.0249             nan     0.0500    0.0010
    10        0.0223             nan     0.0500    0.0013
    20        0.0118             nan     0.0500    0.0007
    40        0.0048             nan     0.0500    0.0002
    60        0.0021             nan     0.0500    0.0000
    80        0.0011             nan     0.0500    0.0000
   100        0.0007             nan     0.0500   -0.0000
   120        0.0005             nan     0.0500    0.0000
   140        0.0003             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold23: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold23: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0412             nan     0.0500    0.0029
     2        0.0388             nan     0.0500    0.0011
     3        0.0358             nan     0.0500    0.0024
     4        0.0333             nan     0.0500    0.0019
     5        0.0312             nan     0.0500    0.0018
     6        0.0298             nan     0.0500    0.0011
     7        0.0282             nan     0.0500    0.0015
     8        0.0267             nan     0.0500    0.0008
     9        0.0251             nan     0.0500    0.0015
    10        0.0237             nan     0.0500    0.0013
    20        0.0143             nan     0.0500    0.0001
    40        0.0064             nan     0.0500   -0.0000
    60        0.0040             nan     0.0500    0.0000
    80        0.0027             nan     0.0500    0.0001
   100        0.0021             nan     0.0500    0.0000
   120        0.0016             nan     0.0500   -0.0000
   140        0.0012             nan     0.0500   -0.0000
   160        0.0009             nan     0.0500    0.0000
   180        0.0007             nan     0.0500   -0.0000
   200        0.0005             nan     0.0500   -0.0000

- Fold23: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold23: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0384             nan     0.1000    0.0031
     2        0.0344             nan     0.1000    0.0018
     3        0.0301             nan     0.1000    0.0038
     4        0.0269             nan     0.1000    0.0010
     5        0.0236             nan     0.1000    0.0032
     6        0.0204             nan     0.1000    0.0017
     7        0.0182             nan     0.1000    0.0024
     8        0.0170             nan     0.1000    0.0010
     9        0.0162             nan     0.1000   -0.0000
    10        0.0143             nan     0.1000    0.0015
    20        0.0058             nan     0.1000    0.0004
    40        0.0014             nan     0.1000   -0.0000
    60        0.0004             nan     0.1000   -0.0000
    80        0.0002             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000    0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold23: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold23: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0382             nan     0.1000    0.0052
     2        0.0343             nan     0.1000    0.0004
     3        0.0320             nan     0.1000    0.0006
     4        0.0272             nan     0.1000    0.0034
     5        0.0256             nan     0.1000    0.0006
     6        0.0225             nan     0.1000    0.0021
     7        0.0191             nan     0.1000    0.0024
     8        0.0186             nan     0.1000   -0.0001
     9        0.0172             nan     0.1000    0.0011
    10        0.0153             nan     0.1000    0.0021
    20        0.0062             nan     0.1000    0.0003
    40        0.0018             nan     0.1000   -0.0000
    60        0.0008             nan     0.1000   -0.0001
    80        0.0004             nan     0.1000    0.0000
   100        0.0002             nan     0.1000    0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold23: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold23: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0385             nan     0.1000    0.0027
     2        0.0350             nan     0.1000    0.0036
     3        0.0317             nan     0.1000    0.0025
     4        0.0286             nan     0.1000    0.0037
     5        0.0265             nan     0.1000    0.0007
     6        0.0248             nan     0.1000    0.0005
     7        0.0224             nan     0.1000    0.0019
     8        0.0201             nan     0.1000    0.0025
     9        0.0188             nan     0.1000    0.0012
    10        0.0177             nan     0.1000    0.0001
    20        0.0113             nan     0.1000    0.0004
    40        0.0037             nan     0.1000   -0.0002
    60        0.0017             nan     0.1000   -0.0000
    80        0.0012             nan     0.1000   -0.0000
   100        0.0006             nan     0.1000   -0.0000
   120        0.0004             nan     0.1000   -0.0000
   140        0.0003             nan     0.1000    0.0000
   160        0.0002             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000    0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold23: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold23: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0395             nan     0.1000    0.0041
     2        0.0344             nan     0.1000    0.0033
     3        0.0291             nan     0.1000    0.0059
     4        0.0270             nan     0.1000    0.0013
     5        0.0239             nan     0.1000    0.0026
     6        0.0217             nan     0.1000    0.0009
     7        0.0200             nan     0.1000    0.0015
     8        0.0182             nan     0.1000    0.0014
     9        0.0168             nan     0.1000    0.0003
    10        0.0151             nan     0.1000    0.0007
    20        0.0053             nan     0.1000    0.0005
    40        0.0008             nan     0.1000   -0.0000
    60        0.0002             nan     0.1000   -0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000    0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold23: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold23: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0406             nan     0.1000   -0.0017
     2        0.0357             nan     0.1000    0.0052
     3        0.0338             nan     0.1000    0.0004
     4        0.0297             nan     0.1000    0.0018
     5        0.0257             nan     0.1000    0.0035
     6        0.0238             nan     0.1000    0.0008
     7        0.0202             nan     0.1000    0.0034
     8        0.0178             nan     0.1000    0.0017
     9        0.0159             nan     0.1000    0.0005
    10        0.0151             nan     0.1000   -0.0005
    20        0.0060             nan     0.1000   -0.0005
    40        0.0016             nan     0.1000    0.0001
    60        0.0006             nan     0.1000    0.0000
    80        0.0002             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold23: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold23: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0387             nan     0.1000    0.0058
     2        0.0346             nan     0.1000    0.0048
     3        0.0302             nan     0.1000    0.0032
     4        0.0270             nan     0.1000    0.0013
     5        0.0242             nan     0.1000   -0.0007
     6        0.0214             nan     0.1000    0.0026
     7        0.0197             nan     0.1000    0.0021
     8        0.0185             nan     0.1000    0.0009
     9        0.0166             nan     0.1000    0.0017
    10        0.0151             nan     0.1000    0.0015
    20        0.0078             nan     0.1000   -0.0001
    40        0.0035             nan     0.1000    0.0000
    60        0.0018             nan     0.1000    0.0000
    80        0.0008             nan     0.1000    0.0000
   100        0.0005             nan     0.1000   -0.0000
   120        0.0003             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000    0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold23: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold23: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0357             nan     0.1000    0.0071
     2        0.0320             nan     0.1000    0.0004
     3        0.0280             nan     0.1000    0.0011
     4        0.0248             nan     0.1000   -0.0004
     5        0.0237             nan     0.1000   -0.0001
     6        0.0195             nan     0.1000    0.0033
     7        0.0172             nan     0.1000    0.0020
     8        0.0147             nan     0.1000    0.0017
     9        0.0128             nan     0.1000    0.0011
    10        0.0114             nan     0.1000    0.0012
    20        0.0028             nan     0.1000    0.0005
    40        0.0004             nan     0.1000   -0.0000
    60        0.0001             nan     0.1000   -0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000    0.0000
   120        0.0000             nan     0.1000    0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000    0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold23: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold23: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0399             nan     0.1000    0.0030
     2        0.0339             nan     0.1000    0.0052
     3        0.0301             nan     0.1000    0.0037
     4        0.0265             nan     0.1000   -0.0003
     5        0.0231             nan     0.1000    0.0029
     6        0.0203             nan     0.1000    0.0015
     7        0.0179             nan     0.1000    0.0007
     8        0.0156             nan     0.1000    0.0022
     9        0.0132             nan     0.1000    0.0019
    10        0.0115             nan     0.1000    0.0013
    20        0.0038             nan     0.1000    0.0001
    40        0.0010             nan     0.1000   -0.0000
    60        0.0003             nan     0.1000   -0.0000
    80        0.0002             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000    0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000    0.0000

- Fold23: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold23: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0386             nan     0.1000    0.0053
     2        0.0343             nan     0.1000    0.0040
     3        0.0321             nan     0.1000    0.0019
     4        0.0278             nan     0.1000    0.0039
     5        0.0268             nan     0.1000   -0.0007
     6        0.0252             nan     0.1000    0.0008
     7        0.0220             nan     0.1000    0.0026
     8        0.0206             nan     0.1000    0.0003
     9        0.0191             nan     0.1000   -0.0003
    10        0.0172             nan     0.1000    0.0014
    20        0.0071             nan     0.1000    0.0002
    40        0.0032             nan     0.1000   -0.0001
    60        0.0015             nan     0.1000   -0.0000
    80        0.0007             nan     0.1000   -0.0000
   100        0.0005             nan     0.1000   -0.0000
   120        0.0003             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold23: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold24: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0427             nan     0.0100    0.0005
     2        0.0423             nan     0.0100    0.0001
     3        0.0417             nan     0.0100    0.0006
     4        0.0412             nan     0.0100    0.0005
     5        0.0406             nan     0.0100    0.0003
     6        0.0401             nan     0.0100    0.0005
     7        0.0395             nan     0.0100    0.0005
     8        0.0390             nan     0.0100    0.0004
     9        0.0386             nan     0.0100    0.0003
    10        0.0381             nan     0.0100    0.0004
    20        0.0339             nan     0.0100    0.0004
    40        0.0267             nan     0.0100    0.0003
    60        0.0213             nan     0.0100   -0.0001
    80        0.0177             nan     0.0100    0.0001
   100        0.0146             nan     0.0100    0.0000
   120        0.0121             nan     0.0100    0.0001
   140        0.0104             nan     0.0100    0.0001
   160        0.0088             nan     0.0100    0.0000
   180        0.0074             nan     0.0100   -0.0000
   200        0.0063             nan     0.0100    0.0000

- Fold24: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold24: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0426             nan     0.0100    0.0006
     2        0.0422             nan     0.0100    0.0002
     3        0.0419             nan     0.0100    0.0000
     4        0.0413             nan     0.0100    0.0006
     5        0.0409             nan     0.0100    0.0000
     6        0.0405             nan     0.0100    0.0005
     7        0.0401             nan     0.0100    0.0003
     8        0.0396             nan     0.0100    0.0004
     9        0.0391             nan     0.0100    0.0005
    10        0.0388             nan     0.0100    0.0002
    20        0.0344             nan     0.0100   -0.0000
    40        0.0281             nan     0.0100   -0.0000
    60        0.0226             nan     0.0100    0.0002
    80        0.0183             nan     0.0100    0.0002
   100        0.0152             nan     0.0100    0.0001
   120        0.0125             nan     0.0100   -0.0000
   140        0.0106             nan     0.0100    0.0000
   160        0.0089             nan     0.0100    0.0000
   180        0.0076             nan     0.0100   -0.0000
   200        0.0066             nan     0.0100    0.0000

- Fold24: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold24: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0427             nan     0.0100    0.0005
     2        0.0422             nan     0.0100    0.0003
     3        0.0418             nan     0.0100    0.0004
     4        0.0417             nan     0.0100   -0.0003
     5        0.0411             nan     0.0100    0.0004
     6        0.0405             nan     0.0100    0.0005
     7        0.0399             nan     0.0100    0.0005
     8        0.0396             nan     0.0100    0.0001
     9        0.0392             nan     0.0100    0.0002
    10        0.0389             nan     0.0100   -0.0000
    20        0.0347             nan     0.0100    0.0001
    40        0.0284             nan     0.0100    0.0002
    60        0.0238             nan     0.0100    0.0001
    80        0.0192             nan     0.0100    0.0001
   100        0.0157             nan     0.0100    0.0001
   120        0.0136             nan     0.0100    0.0001
   140        0.0117             nan     0.0100   -0.0000
   160        0.0103             nan     0.0100    0.0001
   180        0.0089             nan     0.0100    0.0000
   200        0.0079             nan     0.0100    0.0000

- Fold24: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold24: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0426             nan     0.0100    0.0007
     2        0.0419             nan     0.0100    0.0006
     3        0.0412             nan     0.0100    0.0005
     4        0.0406             nan     0.0100    0.0005
     5        0.0400             nan     0.0100    0.0004
     6        0.0397             nan     0.0100    0.0002
     7        0.0391             nan     0.0100    0.0003
     8        0.0390             nan     0.0100   -0.0002
     9        0.0384             nan     0.0100    0.0004
    10        0.0378             nan     0.0100    0.0006
    20        0.0329             nan     0.0100    0.0003
    40        0.0251             nan     0.0100    0.0002
    60        0.0195             nan     0.0100    0.0003
    80        0.0155             nan     0.0100    0.0001
   100        0.0126             nan     0.0100    0.0000
   120        0.0102             nan     0.0100    0.0001
   140        0.0084             nan     0.0100    0.0000
   160        0.0069             nan     0.0100   -0.0000
   180        0.0056             nan     0.0100    0.0000
   200        0.0045             nan     0.0100    0.0001

- Fold24: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold24: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0426             nan     0.0100    0.0006
     2        0.0420             nan     0.0100    0.0005
     3        0.0413             nan     0.0100    0.0005
     4        0.0406             nan     0.0100    0.0005
     5        0.0401             nan     0.0100    0.0005
     6        0.0397             nan     0.0100    0.0001
     7        0.0393             nan     0.0100    0.0003
     8        0.0389             nan     0.0100    0.0003
     9        0.0386             nan     0.0100    0.0003
    10        0.0378             nan     0.0100    0.0005
    20        0.0322             nan     0.0100    0.0004
    40        0.0246             nan     0.0100    0.0002
    60        0.0191             nan     0.0100    0.0001
    80        0.0150             nan     0.0100    0.0001
   100        0.0118             nan     0.0100    0.0001
   120        0.0094             nan     0.0100    0.0001
   140        0.0078             nan     0.0100    0.0001
   160        0.0066             nan     0.0100    0.0000
   180        0.0054             nan     0.0100   -0.0000
   200        0.0046             nan     0.0100    0.0000

- Fold24: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold24: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0425             nan     0.0100    0.0005
     2        0.0420             nan     0.0100    0.0005
     3        0.0414             nan     0.0100    0.0006
     4        0.0409             nan     0.0100    0.0006
     5        0.0404             nan     0.0100    0.0005
     6        0.0398             nan     0.0100    0.0003
     7        0.0392             nan     0.0100    0.0004
     8        0.0388             nan     0.0100    0.0002
     9        0.0383             nan     0.0100    0.0003
    10        0.0377             nan     0.0100    0.0004
    20        0.0336             nan     0.0100    0.0002
    40        0.0269             nan     0.0100    0.0003
    60        0.0219             nan     0.0100    0.0002
    80        0.0186             nan     0.0100    0.0002
   100        0.0159             nan     0.0100    0.0001
   120        0.0136             nan     0.0100    0.0001
   140        0.0120             nan     0.0100   -0.0000
   160        0.0106             nan     0.0100   -0.0000
   180        0.0096             nan     0.0100    0.0000
   200        0.0086             nan     0.0100   -0.0000

- Fold24: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold24: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0427             nan     0.0100    0.0000
     2        0.0420             nan     0.0100    0.0006
     3        0.0417             nan     0.0100   -0.0000
     4        0.0411             nan     0.0100    0.0003
     5        0.0404             nan     0.0100    0.0005
     6        0.0398             nan     0.0100    0.0004
     7        0.0391             nan     0.0100    0.0005
     8        0.0387             nan     0.0100    0.0005
     9        0.0381             nan     0.0100    0.0004
    10        0.0374             nan     0.0100    0.0006
    20        0.0330             nan     0.0100    0.0003
    40        0.0246             nan     0.0100    0.0003
    60        0.0187             nan     0.0100    0.0000
    80        0.0140             nan     0.0100    0.0001
   100        0.0109             nan     0.0100    0.0001
   120        0.0087             nan     0.0100    0.0001
   140        0.0068             nan     0.0100    0.0000
   160        0.0054             nan     0.0100    0.0001
   180        0.0043             nan     0.0100    0.0000
   200        0.0034             nan     0.0100    0.0000

- Fold24: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold24: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0425             nan     0.0100    0.0006
     2        0.0418             nan     0.0100    0.0006
     3        0.0412             nan     0.0100    0.0004
     4        0.0409             nan     0.0100   -0.0000
     5        0.0403             nan     0.0100    0.0004
     6        0.0397             nan     0.0100    0.0005
     7        0.0391             nan     0.0100    0.0007
     8        0.0385             nan     0.0100    0.0005
     9        0.0377             nan     0.0100    0.0004
    10        0.0372             nan     0.0100    0.0004
    20        0.0320             nan     0.0100    0.0002
    40        0.0243             nan     0.0100    0.0002
    60        0.0190             nan     0.0100    0.0002
    80        0.0150             nan     0.0100    0.0000
   100        0.0121             nan     0.0100    0.0001
   120        0.0095             nan     0.0100    0.0001
   140        0.0077             nan     0.0100    0.0001
   160        0.0062             nan     0.0100    0.0000
   180        0.0050             nan     0.0100    0.0000
   200        0.0041             nan     0.0100   -0.0000

- Fold24: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold24: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0427             nan     0.0100    0.0004
     2        0.0421             nan     0.0100    0.0003
     3        0.0417             nan     0.0100    0.0003
     4        0.0412             nan     0.0100    0.0003
     5        0.0406             nan     0.0100    0.0004
     6        0.0402             nan     0.0100    0.0004
     7        0.0399             nan     0.0100    0.0001
     8        0.0394             nan     0.0100    0.0005
     9        0.0388             nan     0.0100    0.0004
    10        0.0384             nan     0.0100    0.0004
    20        0.0343             nan     0.0100    0.0005
    40        0.0275             nan     0.0100    0.0001
    60        0.0226             nan     0.0100    0.0002
    80        0.0187             nan     0.0100    0.0000
   100        0.0157             nan     0.0100    0.0000
   120        0.0135             nan     0.0100    0.0000
   140        0.0116             nan     0.0100    0.0000
   160        0.0103             nan     0.0100   -0.0000
   180        0.0094             nan     0.0100    0.0001
   200        0.0085             nan     0.0100   -0.0001

- Fold24: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold24: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0413             nan     0.0500    0.0005
     2        0.0395             nan     0.0500    0.0021
     3        0.0362             nan     0.0500    0.0027
     4        0.0336             nan     0.0500    0.0024
     5        0.0319             nan     0.0500    0.0005
     6        0.0299             nan     0.0500    0.0011
     7        0.0282             nan     0.0500    0.0013
     8        0.0261             nan     0.0500    0.0014
     9        0.0246             nan     0.0500    0.0012
    10        0.0234             nan     0.0500    0.0001
    20        0.0144             nan     0.0500    0.0002
    40        0.0065             nan     0.0500    0.0002
    60        0.0030             nan     0.0500   -0.0000
    80        0.0017             nan     0.0500   -0.0000
   100        0.0010             nan     0.0500   -0.0000
   120        0.0006             nan     0.0500   -0.0000
   140        0.0003             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold24: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold24: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0409             nan     0.0500    0.0022
     2        0.0378             nan     0.0500    0.0020
     3        0.0366             nan     0.0500   -0.0009
     4        0.0341             nan     0.0500    0.0016
     5        0.0329             nan     0.0500    0.0011
     6        0.0310             nan     0.0500    0.0010
     7        0.0285             nan     0.0500    0.0019
     8        0.0267             nan     0.0500    0.0013
     9        0.0263             nan     0.0500   -0.0003
    10        0.0247             nan     0.0500    0.0016
    20        0.0149             nan     0.0500    0.0003
    40        0.0065             nan     0.0500   -0.0000
    60        0.0033             nan     0.0500   -0.0000
    80        0.0023             nan     0.0500   -0.0001
   100        0.0013             nan     0.0500   -0.0000
   120        0.0008             nan     0.0500   -0.0000
   140        0.0005             nan     0.0500   -0.0000
   160        0.0004             nan     0.0500    0.0000
   180        0.0003             nan     0.0500    0.0000
   200        0.0002             nan     0.0500   -0.0000

- Fold24: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold24: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0412             nan     0.0500    0.0017
     2        0.0381             nan     0.0500    0.0029
     3        0.0358             nan     0.0500    0.0014
     4        0.0339             nan     0.0500    0.0011
     5        0.0320             nan     0.0500    0.0021
     6        0.0297             nan     0.0500    0.0017
     7        0.0279             nan     0.0500    0.0014
     8        0.0263             nan     0.0500    0.0015
     9        0.0249             nan     0.0500    0.0014
    10        0.0233             nan     0.0500    0.0010
    20        0.0160             nan     0.0500    0.0004
    40        0.0082             nan     0.0500   -0.0000
    60        0.0050             nan     0.0500    0.0000
    80        0.0034             nan     0.0500    0.0000
   100        0.0026             nan     0.0500    0.0000
   120        0.0017             nan     0.0500   -0.0000
   140        0.0012             nan     0.0500   -0.0000
   160        0.0008             nan     0.0500    0.0000
   180        0.0006             nan     0.0500   -0.0000
   200        0.0004             nan     0.0500   -0.0000

- Fold24: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold24: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0397             nan     0.0500    0.0020
     2        0.0362             nan     0.0500    0.0030
     3        0.0327             nan     0.0500    0.0033
     4        0.0312             nan     0.0500    0.0013
     5        0.0300             nan     0.0500    0.0002
     6        0.0276             nan     0.0500    0.0007
     7        0.0254             nan     0.0500    0.0026
     8        0.0235             nan     0.0500    0.0012
     9        0.0225             nan     0.0500    0.0009
    10        0.0211             nan     0.0500    0.0014
    20        0.0107             nan     0.0500    0.0003
    40        0.0035             nan     0.0500    0.0001
    60        0.0013             nan     0.0500   -0.0000
    80        0.0006             nan     0.0500   -0.0000
   100        0.0003             nan     0.0500    0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0001             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500    0.0000
   180        0.0000             nan     0.0500    0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold24: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold24: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0406             nan     0.0500    0.0030
     2        0.0380             nan     0.0500    0.0015
     3        0.0355             nan     0.0500    0.0026
     4        0.0337             nan     0.0500    0.0013
     5        0.0311             nan     0.0500    0.0021
     6        0.0291             nan     0.0500    0.0013
     7        0.0275             nan     0.0500    0.0016
     8        0.0261             nan     0.0500    0.0007
     9        0.0246             nan     0.0500    0.0013
    10        0.0228             nan     0.0500    0.0014
    20        0.0121             nan     0.0500    0.0007
    40        0.0048             nan     0.0500    0.0001
    60        0.0022             nan     0.0500   -0.0001
    80        0.0010             nan     0.0500    0.0000
   100        0.0006             nan     0.0500   -0.0000
   120        0.0004             nan     0.0500    0.0000
   140        0.0003             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold24: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold24: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0414             nan     0.0500    0.0010
     2        0.0394             nan     0.0500    0.0005
     3        0.0369             nan     0.0500    0.0023
     4        0.0345             nan     0.0500    0.0018
     5        0.0331             nan     0.0500    0.0011
     6        0.0320             nan     0.0500    0.0001
     7        0.0294             nan     0.0500    0.0018
     8        0.0289             nan     0.0500   -0.0007
     9        0.0282             nan     0.0500   -0.0001
    10        0.0267             nan     0.0500    0.0010
    20        0.0162             nan     0.0500   -0.0000
    40        0.0085             nan     0.0500   -0.0000
    60        0.0052             nan     0.0500    0.0001
    80        0.0034             nan     0.0500   -0.0001
   100        0.0022             nan     0.0500    0.0000
   120        0.0017             nan     0.0500   -0.0000
   140        0.0012             nan     0.0500    0.0000
   160        0.0009             nan     0.0500   -0.0000
   180        0.0007             nan     0.0500   -0.0000
   200        0.0005             nan     0.0500   -0.0000

- Fold24: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold24: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0393             nan     0.0500    0.0038
     2        0.0357             nan     0.0500    0.0031
     3        0.0328             nan     0.0500    0.0007
     4        0.0299             nan     0.0500    0.0017
     5        0.0287             nan     0.0500    0.0008
     6        0.0266             nan     0.0500    0.0018
     7        0.0248             nan     0.0500    0.0010
     8        0.0232             nan     0.0500    0.0014
     9        0.0219             nan     0.0500    0.0008
    10        0.0202             nan     0.0500    0.0015
    20        0.0100             nan     0.0500    0.0003
    40        0.0032             nan     0.0500    0.0001
    60        0.0011             nan     0.0500    0.0000
    80        0.0005             nan     0.0500    0.0000
   100        0.0002             nan     0.0500   -0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0000             nan     0.0500    0.0000
   160        0.0000             nan     0.0500    0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold24: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold24: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0408             nan     0.0500    0.0025
     2        0.0384             nan     0.0500    0.0027
     3        0.0370             nan     0.0500    0.0010
     4        0.0340             nan     0.0500    0.0021
     5        0.0325             nan     0.0500    0.0009
     6        0.0303             nan     0.0500    0.0021
     7        0.0286             nan     0.0500    0.0012
     8        0.0267             nan     0.0500    0.0010
     9        0.0245             nan     0.0500    0.0014
    10        0.0232             nan     0.0500    0.0010
    20        0.0119             nan     0.0500    0.0008
    40        0.0041             nan     0.0500    0.0001
    60        0.0018             nan     0.0500    0.0000
    80        0.0011             nan     0.0500   -0.0000
   100        0.0006             nan     0.0500    0.0000
   120        0.0004             nan     0.0500   -0.0000
   140        0.0003             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold24: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold24: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0407             nan     0.0500    0.0014
     2        0.0378             nan     0.0500    0.0028
     3        0.0359             nan     0.0500   -0.0000
     4        0.0341             nan     0.0500    0.0009
     5        0.0317             nan     0.0500    0.0017
     6        0.0297             nan     0.0500    0.0018
     7        0.0282             nan     0.0500    0.0014
     8        0.0266             nan     0.0500    0.0003
     9        0.0248             nan     0.0500    0.0014
    10        0.0233             nan     0.0500    0.0007
    20        0.0144             nan     0.0500    0.0003
    40        0.0082             nan     0.0500   -0.0002
    60        0.0053             nan     0.0500   -0.0000
    80        0.0034             nan     0.0500   -0.0000
   100        0.0023             nan     0.0500    0.0000
   120        0.0017             nan     0.0500    0.0000
   140        0.0014             nan     0.0500   -0.0000
   160        0.0010             nan     0.0500    0.0000
   180        0.0008             nan     0.0500   -0.0000
   200        0.0006             nan     0.0500   -0.0000

- Fold24: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold24: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0383             nan     0.1000    0.0056
     2        0.0342             nan     0.1000    0.0034
     3        0.0302             nan     0.1000    0.0042
     4        0.0268             nan     0.1000    0.0031
     5        0.0237             nan     0.1000    0.0020
     6        0.0206             nan     0.1000    0.0027
     7        0.0182             nan     0.1000    0.0013
     8        0.0165             nan     0.1000    0.0012
     9        0.0153             nan     0.1000    0.0010
    10        0.0142             nan     0.1000    0.0010
    20        0.0060             nan     0.1000    0.0002
    40        0.0015             nan     0.1000    0.0001
    60        0.0005             nan     0.1000    0.0000
    80        0.0002             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000    0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold24: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold24: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0401             nan     0.1000   -0.0005
     2        0.0339             nan     0.1000    0.0044
     3        0.0302             nan     0.1000    0.0031
     4        0.0274             nan     0.1000    0.0030
     5        0.0255             nan     0.1000    0.0008
     6        0.0246             nan     0.1000   -0.0011
     7        0.0210             nan     0.1000    0.0021
     8        0.0195             nan     0.1000    0.0001
     9        0.0181             nan     0.1000    0.0004
    10        0.0159             nan     0.1000    0.0009
    20        0.0082             nan     0.1000    0.0002
    40        0.0027             nan     0.1000   -0.0001
    60        0.0013             nan     0.1000   -0.0001
    80        0.0006             nan     0.1000   -0.0000
   100        0.0003             nan     0.1000   -0.0000
   120        0.0002             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000    0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold24: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold24: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0391             nan     0.1000    0.0005
     2        0.0341             nan     0.1000    0.0049
     3        0.0292             nan     0.1000    0.0037
     4        0.0263             nan     0.1000    0.0032
     5        0.0234             nan     0.1000    0.0031
     6        0.0207             nan     0.1000    0.0015
     7        0.0197             nan     0.1000    0.0004
     8        0.0175             nan     0.1000    0.0017
     9        0.0164             nan     0.1000    0.0012
    10        0.0157             nan     0.1000    0.0004
    20        0.0080             nan     0.1000   -0.0000
    40        0.0041             nan     0.1000   -0.0001
    60        0.0022             nan     0.1000    0.0000
    80        0.0014             nan     0.1000   -0.0001
   100        0.0008             nan     0.1000    0.0000
   120        0.0004             nan     0.1000    0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000    0.0000
   200        0.0001             nan     0.1000    0.0000

- Fold24: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold24: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0391             nan     0.1000    0.0021
     2        0.0363             nan     0.1000   -0.0000
     3        0.0313             nan     0.1000    0.0051
     4        0.0261             nan     0.1000    0.0046
     5        0.0236             nan     0.1000    0.0019
     6        0.0207             nan     0.1000    0.0013
     7        0.0175             nan     0.1000    0.0020
     8        0.0155             nan     0.1000    0.0007
     9        0.0134             nan     0.1000    0.0017
    10        0.0125             nan     0.1000    0.0004
    20        0.0036             nan     0.1000    0.0003
    40        0.0007             nan     0.1000    0.0000
    60        0.0002             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold24: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold24: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0383             nan     0.1000    0.0017
     2        0.0324             nan     0.1000    0.0051
     3        0.0286             nan     0.1000    0.0031
     4        0.0240             nan     0.1000    0.0038
     5        0.0199             nan     0.1000    0.0019
     6        0.0172             nan     0.1000    0.0015
     7        0.0152             nan     0.1000    0.0018
     8        0.0138             nan     0.1000    0.0010
     9        0.0122             nan     0.1000    0.0015
    10        0.0111             nan     0.1000    0.0005
    20        0.0041             nan     0.1000    0.0003
    40        0.0010             nan     0.1000   -0.0001
    60        0.0003             nan     0.1000    0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold24: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold24: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0377             nan     0.1000    0.0050
     2        0.0355             nan     0.1000    0.0000
     3        0.0306             nan     0.1000    0.0040
     4        0.0276             nan     0.1000    0.0029
     5        0.0255             nan     0.1000    0.0007
     6        0.0218             nan     0.1000    0.0015
     7        0.0194             nan     0.1000    0.0016
     8        0.0172             nan     0.1000    0.0005
     9        0.0164             nan     0.1000    0.0009
    10        0.0161             nan     0.1000   -0.0002
    20        0.0087             nan     0.1000    0.0003
    40        0.0039             nan     0.1000    0.0001
    60        0.0019             nan     0.1000    0.0000
    80        0.0013             nan     0.1000   -0.0000
   100        0.0008             nan     0.1000   -0.0001
   120        0.0005             nan     0.1000   -0.0000
   140        0.0003             nan     0.1000   -0.0000
   160        0.0002             nan     0.1000   -0.0000
   180        0.0002             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold24: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold24: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0370             nan     0.1000    0.0030
     2        0.0335             nan     0.1000   -0.0008
     3        0.0278             nan     0.1000    0.0039
     4        0.0230             nan     0.1000    0.0034
     5        0.0212             nan     0.1000    0.0016
     6        0.0184             nan     0.1000    0.0010
     7        0.0165             nan     0.1000    0.0009
     8        0.0139             nan     0.1000    0.0027
     9        0.0119             nan     0.1000    0.0010
    10        0.0109             nan     0.1000   -0.0001
    20        0.0033             nan     0.1000    0.0004
    40        0.0004             nan     0.1000   -0.0000
    60        0.0001             nan     0.1000   -0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000    0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold24: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold24: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0358             nan     0.1000    0.0075
     2        0.0322             nan     0.1000    0.0026
     3        0.0282             nan     0.1000    0.0037
     4        0.0247             nan     0.1000    0.0023
     5        0.0218             nan     0.1000    0.0024
     6        0.0186             nan     0.1000   -0.0000
     7        0.0162             nan     0.1000    0.0015
     8        0.0149             nan     0.1000    0.0010
     9        0.0138             nan     0.1000    0.0008
    10        0.0119             nan     0.1000    0.0020
    20        0.0038             nan     0.1000    0.0002
    40        0.0014             nan     0.1000   -0.0000
    60        0.0006             nan     0.1000   -0.0000
    80        0.0002             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0001             nan     0.1000    0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold24: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold24: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0374             nan     0.1000    0.0039
     2        0.0344             nan     0.1000   -0.0008
     3        0.0290             nan     0.1000    0.0036
     4        0.0274             nan     0.1000    0.0002
     5        0.0236             nan     0.1000    0.0008
     6        0.0213             nan     0.1000    0.0011
     7        0.0202             nan     0.1000    0.0011
     8        0.0195             nan     0.1000    0.0005
     9        0.0169             nan     0.1000    0.0014
    10        0.0148             nan     0.1000    0.0004
    20        0.0074             nan     0.1000   -0.0003
    40        0.0037             nan     0.1000   -0.0001
    60        0.0016             nan     0.1000   -0.0000
    80        0.0008             nan     0.1000   -0.0000
   100        0.0004             nan     0.1000   -0.0000
   120        0.0002             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000    0.0000

- Fold24: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold25: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0393             nan     0.0100   -0.0001
     2        0.0391             nan     0.0100   -0.0001
     3        0.0386             nan     0.0100    0.0005
     4        0.0382             nan     0.0100    0.0003
     5        0.0377             nan     0.0100    0.0002
     6        0.0374             nan     0.0100    0.0003
     7        0.0371             nan     0.0100    0.0001
     8        0.0366             nan     0.0100    0.0005
     9        0.0363             nan     0.0100    0.0001
    10        0.0359             nan     0.0100    0.0002
    20        0.0319             nan     0.0100    0.0004
    40        0.0252             nan     0.0100    0.0001
    60        0.0207             nan     0.0100    0.0002
    80        0.0171             nan     0.0100    0.0001
   100        0.0144             nan     0.0100    0.0001
   120        0.0120             nan     0.0100    0.0001
   140        0.0101             nan     0.0100    0.0001
   160        0.0087             nan     0.0100    0.0000
   180        0.0075             nan     0.0100    0.0000
   200        0.0064             nan     0.0100    0.0000

- Fold25: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold25: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0389             nan     0.0100    0.0005
     2        0.0386             nan     0.0100    0.0001
     3        0.0382             nan     0.0100    0.0002
     4        0.0377             nan     0.0100    0.0005
     5        0.0373             nan     0.0100    0.0002
     6        0.0371             nan     0.0100    0.0001
     7        0.0368             nan     0.0100   -0.0000
     8        0.0363             nan     0.0100    0.0006
     9        0.0358             nan     0.0100    0.0004
    10        0.0353             nan     0.0100    0.0005
    20        0.0314             nan     0.0100    0.0001
    40        0.0259             nan     0.0100    0.0000
    60        0.0209             nan     0.0100    0.0002
    80        0.0176             nan     0.0100    0.0001
   100        0.0148             nan     0.0100    0.0001
   120        0.0125             nan     0.0100    0.0001
   140        0.0109             nan     0.0100    0.0001
   160        0.0092             nan     0.0100    0.0000
   180        0.0079             nan     0.0100    0.0000
   200        0.0066             nan     0.0100    0.0001

- Fold25: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold25: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0390             nan     0.0100    0.0005
     2        0.0385             nan     0.0100    0.0004
     3        0.0380             nan     0.0100    0.0003
     4        0.0377             nan     0.0100    0.0002
     5        0.0372             nan     0.0100    0.0001
     6        0.0370             nan     0.0100    0.0001
     7        0.0366             nan     0.0100    0.0004
     8        0.0362             nan     0.0100    0.0005
     9        0.0357             nan     0.0100    0.0004
    10        0.0351             nan     0.0100    0.0005
    20        0.0311             nan     0.0100    0.0001
    40        0.0255             nan     0.0100    0.0002
    60        0.0209             nan     0.0100    0.0001
    80        0.0176             nan     0.0100    0.0001
   100        0.0151             nan     0.0100    0.0001
   120        0.0131             nan     0.0100    0.0001
   140        0.0117             nan     0.0100    0.0000
   160        0.0103             nan     0.0100    0.0000
   180        0.0092             nan     0.0100    0.0000
   200        0.0082             nan     0.0100    0.0000

- Fold25: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold25: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0389             nan     0.0100    0.0005
     2        0.0384             nan     0.0100    0.0005
     3        0.0379             nan     0.0100    0.0005
     4        0.0374             nan     0.0100    0.0002
     5        0.0368             nan     0.0100    0.0006
     6        0.0365             nan     0.0100    0.0000
     7        0.0358             nan     0.0100    0.0006
     8        0.0353             nan     0.0100    0.0004
     9        0.0350             nan     0.0100   -0.0001
    10        0.0345             nan     0.0100    0.0003
    20        0.0302             nan     0.0100    0.0004
    40        0.0231             nan     0.0100    0.0003
    60        0.0184             nan     0.0100    0.0002
    80        0.0143             nan     0.0100    0.0001
   100        0.0113             nan     0.0100    0.0001
   120        0.0090             nan     0.0100    0.0000
   140        0.0072             nan     0.0100    0.0000
   160        0.0058             nan     0.0100   -0.0000
   180        0.0048             nan     0.0100    0.0000
   200        0.0041             nan     0.0100   -0.0000

- Fold25: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold25: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0389             nan     0.0100    0.0006
     2        0.0385             nan     0.0100    0.0004
     3        0.0380             nan     0.0100    0.0004
     4        0.0375             nan     0.0100    0.0003
     5        0.0370             nan     0.0100    0.0000
     6        0.0365             nan     0.0100    0.0004
     7        0.0361             nan     0.0100    0.0004
     8        0.0356             nan     0.0100    0.0002
     9        0.0351             nan     0.0100    0.0003
    10        0.0346             nan     0.0100    0.0005
    20        0.0303             nan     0.0100    0.0005
    40        0.0234             nan     0.0100    0.0002
    60        0.0184             nan     0.0100    0.0002
    80        0.0144             nan     0.0100    0.0001
   100        0.0117             nan     0.0100    0.0001
   120        0.0095             nan     0.0100    0.0001
   140        0.0077             nan     0.0100   -0.0000
   160        0.0064             nan     0.0100    0.0000
   180        0.0055             nan     0.0100    0.0000
   200        0.0046             nan     0.0100   -0.0000

- Fold25: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold25: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0390             nan     0.0100    0.0005
     2        0.0385             nan     0.0100    0.0004
     3        0.0379             nan     0.0100    0.0005
     4        0.0374             nan     0.0100    0.0004
     5        0.0369             nan     0.0100    0.0005
     6        0.0365             nan     0.0100    0.0003
     7        0.0360             nan     0.0100    0.0005
     8        0.0357             nan     0.0100    0.0003
     9        0.0354             nan     0.0100    0.0001
    10        0.0350             nan     0.0100    0.0003
    20        0.0309             nan     0.0100    0.0002
    40        0.0254             nan     0.0100    0.0003
    60        0.0208             nan     0.0100    0.0002
    80        0.0174             nan     0.0100    0.0001
   100        0.0150             nan     0.0100    0.0000
   120        0.0129             nan     0.0100    0.0000
   140        0.0113             nan     0.0100    0.0000
   160        0.0099             nan     0.0100    0.0000
   180        0.0089             nan     0.0100    0.0000
   200        0.0081             nan     0.0100   -0.0000

- Fold25: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold25: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0388             nan     0.0100    0.0007
     2        0.0383             nan     0.0100    0.0003
     3        0.0380             nan     0.0100    0.0002
     4        0.0374             nan     0.0100    0.0005
     5        0.0368             nan     0.0100    0.0005
     6        0.0364             nan     0.0100    0.0003
     7        0.0356             nan     0.0100    0.0006
     8        0.0353             nan     0.0100    0.0002
     9        0.0351             nan     0.0100   -0.0000
    10        0.0347             nan     0.0100    0.0004
    20        0.0299             nan     0.0100    0.0003
    40        0.0235             nan     0.0100   -0.0000
    60        0.0181             nan     0.0100    0.0003
    80        0.0136             nan     0.0100    0.0001
   100        0.0109             nan     0.0100    0.0001
   120        0.0087             nan     0.0100    0.0002
   140        0.0069             nan     0.0100    0.0001
   160        0.0055             nan     0.0100    0.0001
   180        0.0043             nan     0.0100    0.0000
   200        0.0035             nan     0.0100    0.0000

- Fold25: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold25: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0391             nan     0.0100    0.0005
     2        0.0386             nan     0.0100    0.0005
     3        0.0381             nan     0.0100    0.0005
     4        0.0375             nan     0.0100    0.0004
     5        0.0369             nan     0.0100    0.0005
     6        0.0364             nan     0.0100    0.0002
     7        0.0360             nan     0.0100    0.0002
     8        0.0355             nan     0.0100    0.0004
     9        0.0349             nan     0.0100    0.0005
    10        0.0342             nan     0.0100    0.0004
    20        0.0296             nan     0.0100    0.0004
    40        0.0227             nan     0.0100    0.0001
    60        0.0180             nan     0.0100    0.0002
    80        0.0141             nan     0.0100    0.0001
   100        0.0110             nan     0.0100   -0.0000
   120        0.0088             nan     0.0100    0.0001
   140        0.0072             nan     0.0100    0.0000
   160        0.0059             nan     0.0100    0.0001
   180        0.0049             nan     0.0100    0.0000
   200        0.0042             nan     0.0100    0.0000

- Fold25: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold25: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0392             nan     0.0100    0.0004
     2        0.0389             nan     0.0100    0.0001
     3        0.0385             nan     0.0100    0.0001
     4        0.0382             nan     0.0100    0.0002
     5        0.0377             nan     0.0100    0.0004
     6        0.0373             nan     0.0100    0.0004
     7        0.0368             nan     0.0100    0.0004
     8        0.0363             nan     0.0100    0.0005
     9        0.0361             nan     0.0100   -0.0000
    10        0.0356             nan     0.0100    0.0004
    20        0.0318             nan     0.0100    0.0004
    40        0.0256             nan     0.0100    0.0002
    60        0.0214             nan     0.0100    0.0002
    80        0.0178             nan     0.0100    0.0002
   100        0.0152             nan     0.0100    0.0001
   120        0.0131             nan     0.0100    0.0001
   140        0.0116             nan     0.0100    0.0000
   160        0.0104             nan     0.0100    0.0000
   180        0.0094             nan     0.0100    0.0001
   200        0.0084             nan     0.0100    0.0000

- Fold25: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold25: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0373             nan     0.0500    0.0021
     2        0.0354             nan     0.0500    0.0013
     3        0.0329             nan     0.0500    0.0025
     4        0.0311             nan     0.0500    0.0020
     5        0.0298             nan     0.0500    0.0001
     6        0.0290             nan     0.0500   -0.0002
     7        0.0279             nan     0.0500    0.0001
     8        0.0262             nan     0.0500    0.0017
     9        0.0251             nan     0.0500    0.0011
    10        0.0236             nan     0.0500    0.0015
    20        0.0146             nan     0.0500    0.0007
    40        0.0064             nan     0.0500    0.0001
    60        0.0029             nan     0.0500    0.0001
    80        0.0015             nan     0.0500   -0.0000
   100        0.0009             nan     0.0500   -0.0000
   120        0.0006             nan     0.0500   -0.0000
   140        0.0004             nan     0.0500    0.0000
   160        0.0002             nan     0.0500    0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500    0.0000

- Fold25: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold25: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0377             nan     0.0500    0.0004
     2        0.0358             nan     0.0500    0.0009
     3        0.0343             nan     0.0500    0.0014
     4        0.0321             nan     0.0500    0.0023
     5        0.0300             nan     0.0500    0.0017
     6        0.0286             nan     0.0500    0.0013
     7        0.0270             nan     0.0500    0.0015
     8        0.0254             nan     0.0500    0.0013
     9        0.0239             nan     0.0500    0.0014
    10        0.0225             nan     0.0500    0.0006
    20        0.0139             nan     0.0500    0.0008
    40        0.0063             nan     0.0500    0.0001
    60        0.0031             nan     0.0500    0.0000
    80        0.0017             nan     0.0500   -0.0000
   100        0.0010             nan     0.0500   -0.0000
   120        0.0006             nan     0.0500   -0.0000
   140        0.0004             nan     0.0500   -0.0000
   160        0.0003             nan     0.0500   -0.0000
   180        0.0002             nan     0.0500    0.0000
   200        0.0001             nan     0.0500    0.0000

- Fold25: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold25: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0371             nan     0.0500    0.0021
     2        0.0345             nan     0.0500    0.0023
     3        0.0320             nan     0.0500    0.0022
     4        0.0296             nan     0.0500    0.0019
     5        0.0281             nan     0.0500    0.0014
     6        0.0264             nan     0.0500    0.0015
     7        0.0253             nan     0.0500    0.0009
     8        0.0235             nan     0.0500    0.0013
     9        0.0221             nan     0.0500    0.0007
    10        0.0210             nan     0.0500    0.0009
    20        0.0143             nan     0.0500    0.0006
    40        0.0086             nan     0.0500   -0.0002
    60        0.0056             nan     0.0500    0.0001
    80        0.0038             nan     0.0500    0.0000
   100        0.0026             nan     0.0500   -0.0001
   120        0.0018             nan     0.0500    0.0000
   140        0.0014             nan     0.0500   -0.0000
   160        0.0013             nan     0.0500   -0.0000
   180        0.0010             nan     0.0500   -0.0000
   200        0.0008             nan     0.0500    0.0000

- Fold25: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold25: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0368             nan     0.0500    0.0022
     2        0.0345             nan     0.0500    0.0020
     3        0.0319             nan     0.0500    0.0014
     4        0.0295             nan     0.0500    0.0023
     5        0.0285             nan     0.0500   -0.0001
     6        0.0275             nan     0.0500   -0.0001
     7        0.0251             nan     0.0500    0.0018
     8        0.0238             nan     0.0500    0.0008
     9        0.0228             nan     0.0500    0.0008
    10        0.0219             nan     0.0500   -0.0002
    20        0.0127             nan     0.0500    0.0002
    40        0.0047             nan     0.0500    0.0001
    60        0.0018             nan     0.0500    0.0000
    80        0.0007             nan     0.0500   -0.0000
   100        0.0004             nan     0.0500    0.0000
   120        0.0002             nan     0.0500    0.0000
   140        0.0001             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500    0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500    0.0000

- Fold25: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold25: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0370             nan     0.0500    0.0024
     2        0.0344             nan     0.0500    0.0019
     3        0.0326             nan     0.0500    0.0020
     4        0.0301             nan     0.0500    0.0020
     5        0.0288             nan     0.0500    0.0007
     6        0.0268             nan     0.0500    0.0019
     7        0.0250             nan     0.0500    0.0020
     8        0.0228             nan     0.0500    0.0009
     9        0.0216             nan     0.0500    0.0008
    10        0.0208             nan     0.0500    0.0007
    20        0.0127             nan     0.0500   -0.0003
    40        0.0050             nan     0.0500   -0.0000
    60        0.0025             nan     0.0500   -0.0000
    80        0.0015             nan     0.0500    0.0000
   100        0.0009             nan     0.0500   -0.0000
   120        0.0006             nan     0.0500    0.0000
   140        0.0003             nan     0.0500    0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0002             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold25: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold25: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0365             nan     0.0500    0.0024
     2        0.0339             nan     0.0500    0.0017
     3        0.0320             nan     0.0500    0.0017
     4        0.0307             nan     0.0500    0.0004
     5        0.0288             nan     0.0500    0.0020
     6        0.0266             nan     0.0500    0.0016
     7        0.0251             nan     0.0500    0.0014
     8        0.0236             nan     0.0500    0.0014
     9        0.0225             nan     0.0500    0.0007
    10        0.0216             nan     0.0500    0.0008
    20        0.0143             nan     0.0500    0.0003
    40        0.0076             nan     0.0500    0.0001
    60        0.0050             nan     0.0500    0.0000
    80        0.0035             nan     0.0500   -0.0000
   100        0.0024             nan     0.0500   -0.0001
   120        0.0016             nan     0.0500   -0.0000
   140        0.0011             nan     0.0500   -0.0000
   160        0.0009             nan     0.0500   -0.0000
   180        0.0007             nan     0.0500    0.0000
   200        0.0005             nan     0.0500   -0.0000

- Fold25: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold25: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0374             nan     0.0500    0.0021
     2        0.0342             nan     0.0500    0.0016
     3        0.0316             nan     0.0500    0.0017
     4        0.0289             nan     0.0500    0.0017
     5        0.0273             nan     0.0500    0.0013
     6        0.0251             nan     0.0500    0.0007
     7        0.0238             nan     0.0500    0.0003
     8        0.0216             nan     0.0500    0.0019
     9        0.0202             nan     0.0500    0.0011
    10        0.0191             nan     0.0500    0.0008
    20        0.0098             nan     0.0500    0.0005
    40        0.0032             nan     0.0500    0.0000
    60        0.0012             nan     0.0500    0.0000
    80        0.0004             nan     0.0500   -0.0000
   100        0.0002             nan     0.0500    0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0000             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500    0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold25: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold25: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0361             nan     0.0500    0.0030
     2        0.0352             nan     0.0500   -0.0002
     3        0.0324             nan     0.0500    0.0027
     4        0.0294             nan     0.0500    0.0021
     5        0.0273             nan     0.0500    0.0016
     6        0.0252             nan     0.0500    0.0019
     7        0.0235             nan     0.0500    0.0013
     8        0.0215             nan     0.0500    0.0008
     9        0.0198             nan     0.0500    0.0007
    10        0.0186             nan     0.0500    0.0013
    20        0.0111             nan     0.0500    0.0001
    40        0.0038             nan     0.0500    0.0001
    60        0.0020             nan     0.0500    0.0000
    80        0.0011             nan     0.0500   -0.0000
   100        0.0007             nan     0.0500    0.0000
   120        0.0004             nan     0.0500   -0.0000
   140        0.0003             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500    0.0000

- Fold25: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold25: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0360             nan     0.0500    0.0022
     2        0.0340             nan     0.0500    0.0012
     3        0.0317             nan     0.0500    0.0022
     4        0.0298             nan     0.0500    0.0017
     5        0.0280             nan     0.0500    0.0019
     6        0.0268             nan     0.0500    0.0009
     7        0.0258             nan     0.0500    0.0006
     8        0.0246             nan     0.0500    0.0012
     9        0.0231             nan     0.0500    0.0011
    10        0.0225             nan     0.0500    0.0003
    20        0.0145             nan     0.0500    0.0003
    40        0.0082             nan     0.0500   -0.0003
    60        0.0051             nan     0.0500    0.0001
    80        0.0030             nan     0.0500   -0.0001
   100        0.0022             nan     0.0500   -0.0001
   120        0.0016             nan     0.0500    0.0000
   140        0.0012             nan     0.0500   -0.0001
   160        0.0009             nan     0.0500   -0.0000
   180        0.0007             nan     0.0500   -0.0000
   200        0.0006             nan     0.0500    0.0000

- Fold25: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold25: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0363             nan     0.1000    0.0016
     2        0.0313             nan     0.1000    0.0020
     3        0.0281             nan     0.1000    0.0028
     4        0.0239             nan     0.1000    0.0036
     5        0.0224             nan     0.1000    0.0013
     6        0.0199             nan     0.1000    0.0021
     7        0.0179             nan     0.1000   -0.0002
     8        0.0156             nan     0.1000    0.0004
     9        0.0137             nan     0.1000    0.0003
    10        0.0123             nan     0.1000    0.0012
    20        0.0066             nan     0.1000   -0.0001
    40        0.0017             nan     0.1000   -0.0000
    60        0.0008             nan     0.1000   -0.0001
    80        0.0004             nan     0.1000   -0.0000
   100        0.0002             nan     0.1000    0.0000
   120        0.0001             nan     0.1000    0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold25: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold25: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0344             nan     0.1000    0.0052
     2        0.0308             nan     0.1000    0.0044
     3        0.0267             nan     0.1000    0.0015
     4        0.0242             nan     0.1000    0.0023
     5        0.0225             nan     0.1000    0.0017
     6        0.0198             nan     0.1000    0.0028
     7        0.0188             nan     0.1000   -0.0004
     8        0.0167             nan     0.1000    0.0012
     9        0.0150             nan     0.1000   -0.0000
    10        0.0137             nan     0.1000    0.0014
    20        0.0062             nan     0.1000    0.0004
    40        0.0022             nan     0.1000   -0.0000
    60        0.0009             nan     0.1000   -0.0001
    80        0.0004             nan     0.1000   -0.0000
   100        0.0002             nan     0.1000    0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold25: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold25: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0335             nan     0.1000    0.0039
     2        0.0299             nan     0.1000    0.0041
     3        0.0272             nan     0.1000    0.0017
     4        0.0255             nan     0.1000    0.0015
     5        0.0220             nan     0.1000    0.0026
     6        0.0200             nan     0.1000    0.0021
     7        0.0186             nan     0.1000    0.0013
     8        0.0173             nan     0.1000    0.0004
     9        0.0158             nan     0.1000    0.0011
    10        0.0152             nan     0.1000    0.0003
    20        0.0088             nan     0.1000    0.0001
    40        0.0035             nan     0.1000    0.0001
    60        0.0014             nan     0.1000   -0.0001
    80        0.0009             nan     0.1000   -0.0000
   100        0.0005             nan     0.1000   -0.0000
   120        0.0003             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000    0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold25: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold25: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0333             nan     0.1000    0.0063
     2        0.0311             nan     0.1000   -0.0007
     3        0.0271             nan     0.1000    0.0012
     4        0.0236             nan     0.1000    0.0033
     5        0.0210             nan     0.1000    0.0022
     6        0.0191             nan     0.1000    0.0014
     7        0.0171             nan     0.1000    0.0024
     8        0.0154             nan     0.1000    0.0012
     9        0.0136             nan     0.1000    0.0012
    10        0.0119             nan     0.1000    0.0013
    20        0.0045             nan     0.1000    0.0002
    40        0.0008             nan     0.1000   -0.0000
    60        0.0002             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000    0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000    0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold25: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold25: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0349             nan     0.1000    0.0016
     2        0.0297             nan     0.1000    0.0044
     3        0.0251             nan     0.1000    0.0024
     4        0.0221             nan     0.1000    0.0013
     5        0.0205             nan     0.1000    0.0011
     6        0.0191             nan     0.1000    0.0001
     7        0.0163             nan     0.1000    0.0025
     8        0.0137             nan     0.1000    0.0021
     9        0.0121             nan     0.1000    0.0013
    10        0.0109             nan     0.1000    0.0005
    20        0.0037             nan     0.1000    0.0002
    40        0.0010             nan     0.1000   -0.0000
    60        0.0004             nan     0.1000    0.0000
    80        0.0002             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000    0.0000
   180        0.0000             nan     0.1000    0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold25: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold25: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0338             nan     0.1000    0.0049
     2        0.0303             nan     0.1000    0.0029
     3        0.0275             nan     0.1000    0.0030
     4        0.0238             nan     0.1000    0.0026
     5        0.0206             nan     0.1000    0.0022
     6        0.0183             nan     0.1000    0.0005
     7        0.0172             nan     0.1000    0.0006
     8        0.0157             nan     0.1000    0.0007
     9        0.0144             nan     0.1000    0.0005
    10        0.0130             nan     0.1000    0.0013
    20        0.0069             nan     0.1000    0.0003
    40        0.0032             nan     0.1000    0.0000
    60        0.0018             nan     0.1000   -0.0001
    80        0.0010             nan     0.1000   -0.0000
   100        0.0006             nan     0.1000    0.0000
   120        0.0004             nan     0.1000    0.0000
   140        0.0003             nan     0.1000    0.0000
   160        0.0002             nan     0.1000    0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold25: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold25: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0337             nan     0.1000    0.0037
     2        0.0288             nan     0.1000    0.0045
     3        0.0252             nan     0.1000    0.0019
     4        0.0234             nan     0.1000    0.0021
     5        0.0212             nan     0.1000    0.0011
     6        0.0172             nan     0.1000    0.0017
     7        0.0145             nan     0.1000    0.0002
     8        0.0132             nan     0.1000    0.0006
     9        0.0111             nan     0.1000    0.0006
    10        0.0092             nan     0.1000    0.0009
    20        0.0035             nan     0.1000    0.0003
    40        0.0005             nan     0.1000   -0.0000
    60        0.0001             nan     0.1000   -0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000    0.0000
   120        0.0000             nan     0.1000    0.0000
   140        0.0000             nan     0.1000    0.0000
   160        0.0000             nan     0.1000    0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold25: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold25: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0339             nan     0.1000    0.0026
     2        0.0279             nan     0.1000    0.0048
     3        0.0240             nan     0.1000    0.0036
     4        0.0230             nan     0.1000   -0.0015
     5        0.0200             nan     0.1000    0.0022
     6        0.0163             nan     0.1000    0.0010
     7        0.0141             nan     0.1000    0.0004
     8        0.0129             nan     0.1000   -0.0001
     9        0.0115             nan     0.1000    0.0011
    10        0.0107             nan     0.1000    0.0002
    20        0.0038             nan     0.1000    0.0002
    40        0.0010             nan     0.1000   -0.0001
    60        0.0003             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000    0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000    0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold25: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold25: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0342             nan     0.1000    0.0053
     2        0.0308             nan     0.1000    0.0030
     3        0.0272             nan     0.1000    0.0032
     4        0.0242             nan     0.1000    0.0031
     5        0.0217             nan     0.1000    0.0021
     6        0.0193             nan     0.1000    0.0023
     7        0.0180             nan     0.1000    0.0010
     8        0.0162             nan     0.1000    0.0017
     9        0.0154             nan     0.1000    0.0005
    10        0.0139             nan     0.1000    0.0011
    20        0.0081             nan     0.1000    0.0004
    40        0.0038             nan     0.1000   -0.0003
    60        0.0020             nan     0.1000    0.0000
    80        0.0009             nan     0.1000   -0.0000
   100        0.0006             nan     0.1000   -0.0000
   120        0.0003             nan     0.1000    0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0002             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold25: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold26: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0435             nan     0.0100    0.0002
     2        0.0429             nan     0.0100    0.0003
     3        0.0425             nan     0.0100    0.0002
     4        0.0417             nan     0.0100    0.0006
     5        0.0413             nan     0.0100    0.0004
     6        0.0408             nan     0.0100    0.0001
     7        0.0403             nan     0.0100    0.0005
     8        0.0397             nan     0.0100    0.0003
     9        0.0393             nan     0.0100    0.0001
    10        0.0388             nan     0.0100    0.0003
    20        0.0343             nan     0.0100    0.0004
    40        0.0275             nan     0.0100    0.0002
    60        0.0222             nan     0.0100    0.0002
    80        0.0181             nan     0.0100    0.0001
   100        0.0148             nan     0.0100    0.0002
   120        0.0122             nan     0.0100    0.0001
   140        0.0104             nan     0.0100   -0.0000
   160        0.0086             nan     0.0100    0.0000
   180        0.0074             nan     0.0100    0.0000
   200        0.0064             nan     0.0100    0.0000

- Fold26: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold26: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0433             nan     0.0100    0.0005
     2        0.0428             nan     0.0100    0.0005
     3        0.0422             nan     0.0100    0.0005
     4        0.0416             nan     0.0100    0.0005
     5        0.0413             nan     0.0100    0.0003
     6        0.0407             nan     0.0100    0.0004
     7        0.0402             nan     0.0100    0.0005
     8        0.0397             nan     0.0100    0.0005
     9        0.0391             nan     0.0100    0.0005
    10        0.0386             nan     0.0100    0.0002
    20        0.0345             nan     0.0100    0.0005
    40        0.0273             nan     0.0100    0.0004
    60        0.0221             nan     0.0100    0.0001
    80        0.0178             nan     0.0100    0.0002
   100        0.0150             nan     0.0100    0.0001
   120        0.0124             nan     0.0100    0.0000
   140        0.0105             nan     0.0100    0.0001
   160        0.0089             nan     0.0100    0.0000
   180        0.0075             nan     0.0100    0.0000
   200        0.0065             nan     0.0100    0.0000

- Fold26: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold26: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0435             nan     0.0100    0.0001
     2        0.0429             nan     0.0100    0.0003
     3        0.0427             nan     0.0100   -0.0001
     4        0.0422             nan     0.0100    0.0003
     5        0.0416             nan     0.0100    0.0005
     6        0.0411             nan     0.0100    0.0003
     7        0.0406             nan     0.0100    0.0002
     8        0.0399             nan     0.0100    0.0006
     9        0.0394             nan     0.0100    0.0004
    10        0.0389             nan     0.0100    0.0003
    20        0.0349             nan     0.0100    0.0001
    40        0.0277             nan     0.0100    0.0003
    60        0.0222             nan     0.0100    0.0003
    80        0.0188             nan     0.0100    0.0002
   100        0.0156             nan     0.0100   -0.0000
   120        0.0133             nan     0.0100    0.0000
   140        0.0116             nan     0.0100    0.0001
   160        0.0101             nan     0.0100    0.0000
   180        0.0089             nan     0.0100   -0.0001
   200        0.0079             nan     0.0100    0.0000

- Fold26: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold26: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0433             nan     0.0100    0.0005
     2        0.0427             nan     0.0100    0.0003
     3        0.0424             nan     0.0100    0.0003
     4        0.0421             nan     0.0100    0.0003
     5        0.0418             nan     0.0100    0.0001
     6        0.0412             nan     0.0100    0.0006
     7        0.0405             nan     0.0100    0.0008
     8        0.0401             nan     0.0100    0.0003
     9        0.0398             nan     0.0100    0.0001
    10        0.0394             nan     0.0100    0.0002
    20        0.0338             nan     0.0100    0.0003
    40        0.0264             nan     0.0100    0.0000
    60        0.0201             nan     0.0100   -0.0002
    80        0.0155             nan     0.0100    0.0001
   100        0.0121             nan     0.0100    0.0001
   120        0.0093             nan     0.0100    0.0001
   140        0.0074             nan     0.0100    0.0001
   160        0.0058             nan     0.0100    0.0000
   180        0.0049             nan     0.0100   -0.0000
   200        0.0041             nan     0.0100    0.0000

- Fold26: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold26: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0432             nan     0.0100    0.0003
     2        0.0426             nan     0.0100    0.0002
     3        0.0420             nan     0.0100    0.0006
     4        0.0413             nan     0.0100    0.0006
     5        0.0408             nan     0.0100    0.0006
     6        0.0400             nan     0.0100    0.0004
     7        0.0395             nan     0.0100    0.0004
     8        0.0388             nan     0.0100    0.0004
     9        0.0384             nan     0.0100    0.0005
    10        0.0379             nan     0.0100    0.0005
    20        0.0332             nan     0.0100    0.0005
    40        0.0254             nan     0.0100    0.0002
    60        0.0195             nan     0.0100    0.0003
    80        0.0151             nan     0.0100    0.0002
   100        0.0121             nan     0.0100    0.0001
   120        0.0097             nan     0.0100    0.0000
   140        0.0079             nan     0.0100    0.0001
   160        0.0064             nan     0.0100    0.0000
   180        0.0052             nan     0.0100   -0.0000
   200        0.0043             nan     0.0100    0.0000

- Fold26: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold26: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0435             nan     0.0100    0.0004
     2        0.0429             nan     0.0100    0.0006
     3        0.0423             nan     0.0100    0.0005
     4        0.0419             nan     0.0100   -0.0000
     5        0.0416             nan     0.0100    0.0004
     6        0.0412             nan     0.0100    0.0004
     7        0.0407             nan     0.0100    0.0004
     8        0.0401             nan     0.0100    0.0005
     9        0.0397             nan     0.0100    0.0004
    10        0.0393             nan     0.0100    0.0004
    20        0.0351             nan     0.0100    0.0004
    40        0.0287             nan     0.0100    0.0002
    60        0.0236             nan     0.0100    0.0002
    80        0.0197             nan     0.0100    0.0001
   100        0.0168             nan     0.0100    0.0002
   120        0.0140             nan     0.0100    0.0000
   140        0.0120             nan     0.0100   -0.0000
   160        0.0105             nan     0.0100   -0.0000
   180        0.0092             nan     0.0100    0.0001
   200        0.0082             nan     0.0100    0.0001

- Fold26: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold26: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0432             nan     0.0100    0.0004
     2        0.0424             nan     0.0100    0.0007
     3        0.0418             nan     0.0100    0.0004
     4        0.0411             nan     0.0100    0.0007
     5        0.0402             nan     0.0100    0.0006
     6        0.0395             nan     0.0100    0.0004
     7        0.0389             nan     0.0100    0.0006
     8        0.0381             nan     0.0100    0.0006
     9        0.0376             nan     0.0100    0.0002
    10        0.0371             nan     0.0100    0.0003
    20        0.0320             nan     0.0100    0.0002
    40        0.0240             nan     0.0100    0.0003
    60        0.0179             nan     0.0100    0.0002
    80        0.0142             nan     0.0100   -0.0000
   100        0.0110             nan     0.0100    0.0001
   120        0.0085             nan     0.0100    0.0001
   140        0.0064             nan     0.0100    0.0000
   160        0.0051             nan     0.0100    0.0000
   180        0.0041             nan     0.0100    0.0000
   200        0.0033             nan     0.0100    0.0000

- Fold26: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold26: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0431             nan     0.0100    0.0006
     2        0.0428             nan     0.0100   -0.0002
     3        0.0423             nan     0.0100    0.0002
     4        0.0416             nan     0.0100    0.0006
     5        0.0410             nan     0.0100    0.0005
     6        0.0405             nan     0.0100    0.0005
     7        0.0398             nan     0.0100    0.0006
     8        0.0391             nan     0.0100    0.0005
     9        0.0385             nan     0.0100    0.0004
    10        0.0382             nan     0.0100    0.0001
    20        0.0334             nan     0.0100    0.0005
    40        0.0251             nan     0.0100    0.0004
    60        0.0196             nan     0.0100    0.0001
    80        0.0152             nan     0.0100    0.0001
   100        0.0117             nan     0.0100    0.0001
   120        0.0093             nan     0.0100    0.0001
   140        0.0073             nan     0.0100    0.0001
   160        0.0060             nan     0.0100    0.0000
   180        0.0050             nan     0.0100    0.0000
   200        0.0041             nan     0.0100    0.0000

- Fold26: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold26: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0434             nan     0.0100    0.0003
     2        0.0428             nan     0.0100    0.0005
     3        0.0422             nan     0.0100    0.0006
     4        0.0417             nan     0.0100    0.0005
     5        0.0410             nan     0.0100    0.0004
     6        0.0404             nan     0.0100    0.0005
     7        0.0399             nan     0.0100    0.0003
     8        0.0395             nan     0.0100    0.0004
     9        0.0390             nan     0.0100    0.0005
    10        0.0386             nan     0.0100    0.0001
    20        0.0344             nan     0.0100   -0.0000
    40        0.0275             nan     0.0100    0.0003
    60        0.0227             nan     0.0100    0.0003
    80        0.0184             nan     0.0100    0.0002
   100        0.0153             nan     0.0100    0.0002
   120        0.0132             nan     0.0100    0.0001
   140        0.0114             nan     0.0100    0.0001
   160        0.0098             nan     0.0100    0.0000
   180        0.0087             nan     0.0100   -0.0001
   200        0.0077             nan     0.0100    0.0000

- Fold26: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold26: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0412             nan     0.0500    0.0027
     2        0.0390             nan     0.0500    0.0026
     3        0.0360             nan     0.0500    0.0026
     4        0.0338             nan     0.0500    0.0019
     5        0.0316             nan     0.0500    0.0014
     6        0.0293             nan     0.0500    0.0018
     7        0.0280             nan     0.0500    0.0011
     8        0.0266             nan     0.0500    0.0015
     9        0.0250             nan     0.0500    0.0010
    10        0.0236             nan     0.0500    0.0013
    20        0.0136             nan     0.0500    0.0003
    40        0.0053             nan     0.0500    0.0000
    60        0.0027             nan     0.0500    0.0000
    80        0.0012             nan     0.0500    0.0000
   100        0.0006             nan     0.0500    0.0000
   120        0.0004             nan     0.0500   -0.0000
   140        0.0002             nan     0.0500   -0.0000
   160        0.0001             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold26: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold26: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0419             nan     0.0500    0.0003
     2        0.0388             nan     0.0500    0.0027
     3        0.0372             nan     0.0500    0.0019
     4        0.0355             nan     0.0500    0.0019
     5        0.0334             nan     0.0500    0.0020
     6        0.0319             nan     0.0500    0.0019
     7        0.0302             nan     0.0500    0.0014
     8        0.0287             nan     0.0500    0.0015
     9        0.0269             nan     0.0500    0.0014
    10        0.0259             nan     0.0500    0.0007
    20        0.0161             nan     0.0500    0.0004
    40        0.0072             nan     0.0500    0.0001
    60        0.0039             nan     0.0500   -0.0000
    80        0.0024             nan     0.0500    0.0001
   100        0.0015             nan     0.0500    0.0000
   120        0.0010             nan     0.0500   -0.0000
   140        0.0007             nan     0.0500    0.0000
   160        0.0004             nan     0.0500   -0.0000
   180        0.0003             nan     0.0500    0.0000
   200        0.0002             nan     0.0500   -0.0000

- Fold26: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold26: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0417             nan     0.0500   -0.0004
     2        0.0385             nan     0.0500    0.0021
     3        0.0362             nan     0.0500    0.0023
     4        0.0344             nan     0.0500    0.0013
     5        0.0317             nan     0.0500    0.0022
     6        0.0300             nan     0.0500    0.0017
     7        0.0285             nan     0.0500    0.0007
     8        0.0267             nan     0.0500    0.0013
     9        0.0254             nan     0.0500    0.0010
    10        0.0246             nan     0.0500    0.0006
    20        0.0150             nan     0.0500    0.0004
    40        0.0089             nan     0.0500   -0.0001
    60        0.0058             nan     0.0500   -0.0000
    80        0.0036             nan     0.0500   -0.0000
   100        0.0026             nan     0.0500    0.0000
   120        0.0020             nan     0.0500   -0.0000
   140        0.0015             nan     0.0500   -0.0000
   160        0.0011             nan     0.0500   -0.0000
   180        0.0008             nan     0.0500   -0.0000
   200        0.0006             nan     0.0500   -0.0000

- Fold26: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold26: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0398             nan     0.0500    0.0045
     2        0.0365             nan     0.0500    0.0011
     3        0.0338             nan     0.0500    0.0016
     4        0.0315             nan     0.0500    0.0023
     5        0.0292             nan     0.0500    0.0016
     6        0.0266             nan     0.0500    0.0013
     7        0.0255             nan     0.0500    0.0007
     8        0.0238             nan     0.0500    0.0018
     9        0.0228             nan     0.0500    0.0008
    10        0.0212             nan     0.0500    0.0012
    20        0.0122             nan     0.0500    0.0009
    40        0.0042             nan     0.0500    0.0001
    60        0.0014             nan     0.0500    0.0001
    80        0.0007             nan     0.0500    0.0000
   100        0.0003             nan     0.0500    0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0001             nan     0.0500    0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500    0.0000

- Fold26: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold26: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0405             nan     0.0500    0.0023
     2        0.0378             nan     0.0500    0.0021
     3        0.0368             nan     0.0500    0.0002
     4        0.0339             nan     0.0500    0.0025
     5        0.0317             nan     0.0500    0.0004
     6        0.0293             nan     0.0500    0.0007
     7        0.0270             nan     0.0500    0.0016
     8        0.0251             nan     0.0500    0.0011
     9        0.0232             nan     0.0500    0.0012
    10        0.0214             nan     0.0500    0.0015
    20        0.0120             nan     0.0500    0.0001
    40        0.0047             nan     0.0500    0.0000
    60        0.0018             nan     0.0500    0.0000
    80        0.0008             nan     0.0500    0.0000
   100        0.0005             nan     0.0500   -0.0000
   120        0.0003             nan     0.0500   -0.0000
   140        0.0002             nan     0.0500    0.0000
   160        0.0001             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500    0.0000

- Fold26: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold26: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0408             nan     0.0500    0.0027
     2        0.0385             nan     0.0500    0.0022
     3        0.0379             nan     0.0500   -0.0005
     4        0.0363             nan     0.0500    0.0014
     5        0.0342             nan     0.0500    0.0021
     6        0.0332             nan     0.0500    0.0007
     7        0.0308             nan     0.0500    0.0018
     8        0.0295             nan     0.0500    0.0006
     9        0.0281             nan     0.0500    0.0010
    10        0.0264             nan     0.0500    0.0007
    20        0.0165             nan     0.0500    0.0008
    40        0.0082             nan     0.0500    0.0002
    60        0.0042             nan     0.0500    0.0000
    80        0.0028             nan     0.0500   -0.0001
   100        0.0017             nan     0.0500   -0.0000
   120        0.0013             nan     0.0500   -0.0000
   140        0.0009             nan     0.0500    0.0000
   160        0.0007             nan     0.0500   -0.0000
   180        0.0005             nan     0.0500   -0.0000
   200        0.0004             nan     0.0500    0.0000

- Fold26: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold26: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0420             nan     0.0500    0.0012
     2        0.0402             nan     0.0500    0.0018
     3        0.0385             nan     0.0500   -0.0002
     4        0.0359             nan     0.0500    0.0014
     5        0.0338             nan     0.0500    0.0001
     6        0.0321             nan     0.0500    0.0004
     7        0.0290             nan     0.0500    0.0032
     8        0.0279             nan     0.0500   -0.0010
     9        0.0253             nan     0.0500    0.0026
    10        0.0233             nan     0.0500    0.0018
    20        0.0114             nan     0.0500    0.0006
    40        0.0031             nan     0.0500    0.0001
    60        0.0011             nan     0.0500   -0.0001
    80        0.0004             nan     0.0500   -0.0000
   100        0.0002             nan     0.0500   -0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0000             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500    0.0000
   180        0.0000             nan     0.0500    0.0000
   200        0.0000             nan     0.0500    0.0000

- Fold26: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold26: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0424             nan     0.0500   -0.0001
     2        0.0405             nan     0.0500    0.0013
     3        0.0382             nan     0.0500    0.0022
     4        0.0369             nan     0.0500    0.0005
     5        0.0343             nan     0.0500    0.0015
     6        0.0325             nan     0.0500    0.0020
     7        0.0308             nan     0.0500    0.0009
     8        0.0288             nan     0.0500    0.0016
     9        0.0269             nan     0.0500    0.0019
    10        0.0249             nan     0.0500    0.0019
    20        0.0133             nan     0.0500    0.0007
    40        0.0051             nan     0.0500   -0.0000
    60        0.0026             nan     0.0500    0.0000
    80        0.0012             nan     0.0500   -0.0000
   100        0.0007             nan     0.0500   -0.0000
   120        0.0004             nan     0.0500   -0.0000
   140        0.0003             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold26: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold26: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0422             nan     0.0500    0.0014
     2        0.0393             nan     0.0500    0.0030
     3        0.0366             nan     0.0500    0.0025
     4        0.0337             nan     0.0500    0.0021
     5        0.0325             nan     0.0500    0.0008
     6        0.0306             nan     0.0500    0.0008
     7        0.0289             nan     0.0500    0.0017
     8        0.0281             nan     0.0500    0.0003
     9        0.0263             nan     0.0500    0.0015
    10        0.0251             nan     0.0500    0.0014
    20        0.0160             nan     0.0500    0.0002
    40        0.0079             nan     0.0500    0.0003
    60        0.0046             nan     0.0500    0.0001
    80        0.0029             nan     0.0500   -0.0000
   100        0.0021             nan     0.0500   -0.0000
   120        0.0015             nan     0.0500   -0.0000
   140        0.0011             nan     0.0500   -0.0000
   160        0.0008             nan     0.0500   -0.0000
   180        0.0006             nan     0.0500   -0.0000
   200        0.0005             nan     0.0500   -0.0000

- Fold26: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold26: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0380             nan     0.1000    0.0058
     2        0.0330             nan     0.1000    0.0036
     3        0.0306             nan     0.1000    0.0023
     4        0.0270             nan     0.1000    0.0003
     5        0.0246             nan     0.1000    0.0026
     6        0.0219             nan     0.1000    0.0019
     7        0.0199             nan     0.1000    0.0022
     8        0.0183             nan     0.1000    0.0004
     9        0.0166             nan     0.1000    0.0012
    10        0.0145             nan     0.1000    0.0019
    20        0.0067             nan     0.1000    0.0003
    40        0.0016             nan     0.1000   -0.0001
    60        0.0006             nan     0.1000    0.0000
    80        0.0002             nan     0.1000    0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000    0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold26: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold26: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0377             nan     0.1000    0.0047
     2        0.0325             nan     0.1000    0.0049
     3        0.0289             nan     0.1000    0.0011
     4        0.0257             nan     0.1000    0.0017
     5        0.0229             nan     0.1000    0.0030
     6        0.0203             nan     0.1000   -0.0001
     7        0.0181             nan     0.1000    0.0012
     8        0.0157             nan     0.1000    0.0021
     9        0.0141             nan     0.1000    0.0008
    10        0.0126             nan     0.1000    0.0001
    20        0.0053             nan     0.1000    0.0002
    40        0.0017             nan     0.1000   -0.0001
    60        0.0008             nan     0.1000   -0.0000
    80        0.0004             nan     0.1000    0.0000
   100        0.0002             nan     0.1000   -0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000    0.0000

- Fold26: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold26: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0381             nan     0.1000    0.0048
     2        0.0322             nan     0.1000    0.0038
     3        0.0289             nan     0.1000    0.0024
     4        0.0258             nan     0.1000    0.0034
     5        0.0232             nan     0.1000    0.0016
     6        0.0205             nan     0.1000    0.0023
     7        0.0189             nan     0.1000    0.0010
     8        0.0177             nan     0.1000    0.0011
     9        0.0169             nan     0.1000    0.0006
    10        0.0153             nan     0.1000    0.0007
    20        0.0070             nan     0.1000    0.0002
    40        0.0032             nan     0.1000   -0.0000
    60        0.0013             nan     0.1000   -0.0000
    80        0.0007             nan     0.1000   -0.0000
   100        0.0003             nan     0.1000   -0.0000
   120        0.0002             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000    0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold26: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold26: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0379             nan     0.1000    0.0046
     2        0.0324             nan     0.1000    0.0021
     3        0.0272             nan     0.1000    0.0043
     4        0.0242             nan     0.1000    0.0030
     5        0.0217             nan     0.1000    0.0021
     6        0.0182             nan     0.1000    0.0018
     7        0.0161             nan     0.1000    0.0006
     8        0.0134             nan     0.1000    0.0019
     9        0.0115             nan     0.1000    0.0019
    10        0.0103             nan     0.1000    0.0006
    20        0.0031             nan     0.1000    0.0002
    40        0.0006             nan     0.1000   -0.0001
    60        0.0002             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000    0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold26: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold26: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0377             nan     0.1000    0.0066
     2        0.0325             nan     0.1000    0.0053
     3        0.0290             nan     0.1000    0.0026
     4        0.0264             nan     0.1000    0.0023
     5        0.0237             nan     0.1000    0.0020
     6        0.0222             nan     0.1000   -0.0004
     7        0.0191             nan     0.1000    0.0007
     8        0.0177             nan     0.1000   -0.0002
     9        0.0152             nan     0.1000    0.0016
    10        0.0143             nan     0.1000   -0.0005
    20        0.0051             nan     0.1000    0.0004
    40        0.0012             nan     0.1000    0.0000
    60        0.0004             nan     0.1000   -0.0000
    80        0.0002             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000    0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold26: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold26: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0383             nan     0.1000    0.0052
     2        0.0326             nan     0.1000    0.0045
     3        0.0284             nan     0.1000    0.0039
     4        0.0259             nan     0.1000    0.0011
     5        0.0237             nan     0.1000    0.0012
     6        0.0223             nan     0.1000    0.0003
     7        0.0205             nan     0.1000    0.0012
     8        0.0200             nan     0.1000   -0.0020
     9        0.0179             nan     0.1000    0.0016
    10        0.0167             nan     0.1000    0.0006
    20        0.0084             nan     0.1000    0.0004
    40        0.0030             nan     0.1000   -0.0000
    60        0.0013             nan     0.1000   -0.0001
    80        0.0007             nan     0.1000    0.0000
   100        0.0004             nan     0.1000   -0.0000
   120        0.0003             nan     0.1000    0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000    0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold26: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold26: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0365             nan     0.1000    0.0052
     2        0.0313             nan     0.1000    0.0052
     3        0.0283             nan     0.1000    0.0021
     4        0.0244             nan     0.1000    0.0024
     5        0.0210             nan     0.1000    0.0028
     6        0.0203             nan     0.1000   -0.0005
     7        0.0174             nan     0.1000    0.0031
     8        0.0152             nan     0.1000    0.0015
     9        0.0137             nan     0.1000    0.0018
    10        0.0118             nan     0.1000    0.0016
    20        0.0036             nan     0.1000    0.0001
    40        0.0005             nan     0.1000    0.0000
    60        0.0001             nan     0.1000   -0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000    0.0000

- Fold26: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold26: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0378             nan     0.1000    0.0049
     2        0.0315             nan     0.1000    0.0018
     3        0.0271             nan     0.1000    0.0017
     4        0.0236             nan     0.1000    0.0019
     5        0.0209             nan     0.1000    0.0022
     6        0.0178             nan     0.1000    0.0024
     7        0.0154             nan     0.1000    0.0020
     8        0.0137             nan     0.1000    0.0004
     9        0.0119             nan     0.1000    0.0003
    10        0.0103             nan     0.1000    0.0011
    20        0.0044             nan     0.1000    0.0003
    40        0.0010             nan     0.1000    0.0000
    60        0.0003             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000    0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold26: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold26: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0391             nan     0.1000    0.0034
     2        0.0338             nan     0.1000    0.0043
     3        0.0299             nan     0.1000    0.0036
     4        0.0254             nan     0.1000    0.0027
     5        0.0231             nan     0.1000    0.0024
     6        0.0203             nan     0.1000    0.0019
     7        0.0179             nan     0.1000    0.0015
     8        0.0167             nan     0.1000    0.0010
     9        0.0152             nan     0.1000    0.0011
    10        0.0139             nan     0.1000    0.0009
    20        0.0083             nan     0.1000   -0.0002
    40        0.0037             nan     0.1000    0.0001
    60        0.0022             nan     0.1000   -0.0001
    80        0.0013             nan     0.1000   -0.0001
   100        0.0008             nan     0.1000   -0.0000
   120        0.0005             nan     0.1000    0.0000
   140        0.0004             nan     0.1000   -0.0000
   160        0.0002             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold26: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold27: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0439             nan     0.0100    0.0002
     2        0.0433             nan     0.0100    0.0005
     3        0.0427             nan     0.0100    0.0004
     4        0.0422             nan     0.0100    0.0004
     5        0.0415             nan     0.0100    0.0006
     6        0.0412             nan     0.0100   -0.0001
     7        0.0406             nan     0.0100    0.0006
     8        0.0403             nan     0.0100    0.0000
     9        0.0399             nan     0.0100    0.0004
    10        0.0394             nan     0.0100    0.0003
    20        0.0351             nan     0.0100    0.0003
    40        0.0280             nan     0.0100    0.0004
    60        0.0222             nan     0.0100    0.0001
    80        0.0179             nan     0.0100   -0.0000
   100        0.0148             nan     0.0100    0.0000
   120        0.0123             nan     0.0100    0.0001
   140        0.0101             nan     0.0100    0.0001
   160        0.0086             nan     0.0100    0.0000
   180        0.0073             nan     0.0100   -0.0000
   200        0.0061             nan     0.0100    0.0000

- Fold27: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold27: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0436             nan     0.0100    0.0006
     2        0.0429             nan     0.0100    0.0006
     3        0.0425             nan     0.0100    0.0003
     4        0.0418             nan     0.0100    0.0006
     5        0.0413             nan     0.0100    0.0005
     6        0.0407             nan     0.0100    0.0006
     7        0.0401             nan     0.0100    0.0005
     8        0.0397             nan     0.0100    0.0002
     9        0.0394             nan     0.0100    0.0002
    10        0.0389             nan     0.0100    0.0002
    20        0.0348             nan     0.0100    0.0000
    40        0.0275             nan     0.0100    0.0002
    60        0.0226             nan     0.0100    0.0001
    80        0.0186             nan     0.0100    0.0001
   100        0.0150             nan     0.0100    0.0001
   120        0.0124             nan     0.0100    0.0001
   140        0.0103             nan     0.0100    0.0000
   160        0.0086             nan     0.0100    0.0001
   180        0.0072             nan     0.0100    0.0000
   200        0.0061             nan     0.0100    0.0000

- Fold27: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold27: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0437             nan     0.0100    0.0006
     2        0.0430             nan     0.0100    0.0005
     3        0.0425             nan     0.0100    0.0005
     4        0.0419             nan     0.0100    0.0006
     5        0.0413             nan     0.0100    0.0004
     6        0.0409             nan     0.0100    0.0004
     7        0.0404             nan     0.0100    0.0003
     8        0.0399             nan     0.0100    0.0005
     9        0.0394             nan     0.0100    0.0004
    10        0.0389             nan     0.0100    0.0002
    20        0.0346             nan     0.0100    0.0005
    40        0.0276             nan     0.0100    0.0002
    60        0.0227             nan     0.0100    0.0002
    80        0.0187             nan     0.0100    0.0001
   100        0.0158             nan     0.0100    0.0001
   120        0.0137             nan     0.0100    0.0001
   140        0.0121             nan     0.0100    0.0000
   160        0.0106             nan     0.0100    0.0000
   180        0.0095             nan     0.0100   -0.0000
   200        0.0085             nan     0.0100    0.0000

- Fold27: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold27: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0434             nan     0.0100    0.0008
     2        0.0427             nan     0.0100    0.0005
     3        0.0422             nan     0.0100    0.0003
     4        0.0415             nan     0.0100    0.0009
     5        0.0409             nan     0.0100    0.0005
     6        0.0403             nan     0.0100    0.0005
     7        0.0397             nan     0.0100    0.0003
     8        0.0392             nan     0.0100    0.0002
     9        0.0390             nan     0.0100   -0.0001
    10        0.0383             nan     0.0100    0.0008
    20        0.0329             nan     0.0100    0.0005
    40        0.0246             nan     0.0100    0.0002
    60        0.0191             nan     0.0100    0.0003
    80        0.0147             nan     0.0100    0.0001
   100        0.0116             nan     0.0100    0.0001
   120        0.0093             nan     0.0100    0.0001
   140        0.0075             nan     0.0100    0.0000
   160        0.0061             nan     0.0100    0.0000
   180        0.0049             nan     0.0100    0.0000
   200        0.0039             nan     0.0100    0.0000

- Fold27: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold27: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0438             nan     0.0100    0.0002
     2        0.0431             nan     0.0100    0.0005
     3        0.0426             nan     0.0100    0.0005
     4        0.0419             nan     0.0100    0.0007
     5        0.0416             nan     0.0100   -0.0001
     6        0.0409             nan     0.0100    0.0005
     7        0.0402             nan     0.0100    0.0006
     8        0.0397             nan     0.0100    0.0001
     9        0.0391             nan     0.0100    0.0006
    10        0.0386             nan     0.0100    0.0004
    20        0.0337             nan     0.0100    0.0003
    40        0.0255             nan     0.0100    0.0002
    60        0.0204             nan     0.0100    0.0002
    80        0.0164             nan     0.0100    0.0001
   100        0.0129             nan     0.0100    0.0001
   120        0.0103             nan     0.0100    0.0001
   140        0.0082             nan     0.0100    0.0000
   160        0.0068             nan     0.0100    0.0001
   180        0.0055             nan     0.0100    0.0000
   200        0.0046             nan     0.0100   -0.0000

- Fold27: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold27: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0438             nan     0.0100    0.0005
     2        0.0431             nan     0.0100    0.0006
     3        0.0426             nan     0.0100    0.0005
     4        0.0423             nan     0.0100    0.0003
     5        0.0418             nan     0.0100    0.0003
     6        0.0415             nan     0.0100    0.0000
     7        0.0412             nan     0.0100    0.0001
     8        0.0407             nan     0.0100    0.0004
     9        0.0402             nan     0.0100    0.0005
    10        0.0398             nan     0.0100    0.0003
    20        0.0353             nan     0.0100    0.0003
    40        0.0283             nan     0.0100    0.0003
    60        0.0231             nan     0.0100    0.0003
    80        0.0194             nan     0.0100   -0.0000
   100        0.0164             nan     0.0100    0.0000
   120        0.0140             nan     0.0100    0.0001
   140        0.0120             nan     0.0100    0.0000
   160        0.0105             nan     0.0100    0.0000
   180        0.0093             nan     0.0100   -0.0001
   200        0.0082             nan     0.0100    0.0000

- Fold27: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold27: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0437             nan     0.0100    0.0005
     2        0.0429             nan     0.0100    0.0009
     3        0.0422             nan     0.0100    0.0006
     4        0.0414             nan     0.0100    0.0005
     5        0.0406             nan     0.0100    0.0006
     6        0.0400             nan     0.0100    0.0005
     7        0.0394             nan     0.0100    0.0006
     8        0.0390             nan     0.0100   -0.0001
     9        0.0385             nan     0.0100    0.0004
    10        0.0378             nan     0.0100    0.0005
    20        0.0328             nan     0.0100    0.0000
    40        0.0248             nan     0.0100    0.0003
    60        0.0185             nan     0.0100    0.0001
    80        0.0140             nan     0.0100    0.0001
   100        0.0106             nan     0.0100    0.0001
   120        0.0083             nan     0.0100   -0.0000
   140        0.0064             nan     0.0100   -0.0000
   160        0.0051             nan     0.0100    0.0000
   180        0.0040             nan     0.0100   -0.0000
   200        0.0032             nan     0.0100    0.0000

- Fold27: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold27: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0436             nan     0.0100    0.0007
     2        0.0430             nan     0.0100    0.0005
     3        0.0423             nan     0.0100    0.0007
     4        0.0418             nan     0.0100    0.0004
     5        0.0415             nan     0.0100    0.0001
     6        0.0409             nan     0.0100    0.0005
     7        0.0402             nan     0.0100    0.0006
     8        0.0396             nan     0.0100    0.0005
     9        0.0391             nan     0.0100    0.0004
    10        0.0386             nan     0.0100    0.0004
    20        0.0333             nan     0.0100    0.0003
    40        0.0253             nan     0.0100    0.0002
    60        0.0190             nan     0.0100    0.0003
    80        0.0147             nan     0.0100    0.0002
   100        0.0119             nan     0.0100    0.0001
   120        0.0093             nan     0.0100    0.0001
   140        0.0075             nan     0.0100    0.0000
   160        0.0061             nan     0.0100    0.0000
   180        0.0048             nan     0.0100    0.0000
   200        0.0039             nan     0.0100    0.0000

- Fold27: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold27: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0437             nan     0.0100    0.0004
     2        0.0433             nan     0.0100    0.0001
     3        0.0426             nan     0.0100    0.0006
     4        0.0421             nan     0.0100    0.0005
     5        0.0415             nan     0.0100    0.0005
     6        0.0410             nan     0.0100    0.0006
     7        0.0404             nan     0.0100    0.0004
     8        0.0398             nan     0.0100    0.0005
     9        0.0397             nan     0.0100   -0.0003
    10        0.0392             nan     0.0100    0.0005
    20        0.0345             nan     0.0100    0.0004
    40        0.0277             nan     0.0100    0.0001
    60        0.0227             nan     0.0100    0.0002
    80        0.0190             nan     0.0100    0.0000
   100        0.0162             nan     0.0100    0.0001
   120        0.0138             nan     0.0100    0.0001
   140        0.0118             nan     0.0100    0.0001
   160        0.0102             nan     0.0100    0.0001
   180        0.0091             nan     0.0100    0.0000
   200        0.0081             nan     0.0100    0.0000

- Fold27: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold27: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0406             nan     0.0500    0.0028
     2        0.0381             nan     0.0500    0.0027
     3        0.0352             nan     0.0500    0.0020
     4        0.0325             nan     0.0500    0.0027
     5        0.0299             nan     0.0500    0.0015
     6        0.0285             nan     0.0500    0.0012
     7        0.0271             nan     0.0500    0.0011
     8        0.0254             nan     0.0500    0.0014
     9        0.0231             nan     0.0500    0.0020
    10        0.0224             nan     0.0500    0.0002
    20        0.0137             nan     0.0500    0.0005
    40        0.0050             nan     0.0500    0.0000
    60        0.0025             nan     0.0500   -0.0000
    80        0.0014             nan     0.0500   -0.0000
   100        0.0007             nan     0.0500    0.0000
   120        0.0005             nan     0.0500   -0.0000
   140        0.0003             nan     0.0500   -0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold27: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold27: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0412             nan     0.0500    0.0024
     2        0.0383             nan     0.0500    0.0029
     3        0.0359             nan     0.0500    0.0019
     4        0.0343             nan     0.0500    0.0019
     5        0.0326             nan     0.0500    0.0008
     6        0.0307             nan     0.0500    0.0016
     7        0.0289             nan     0.0500    0.0015
     8        0.0275             nan     0.0500    0.0012
     9        0.0268             nan     0.0500   -0.0000
    10        0.0254             nan     0.0500    0.0016
    20        0.0151             nan     0.0500    0.0005
    40        0.0059             nan     0.0500    0.0001
    60        0.0031             nan     0.0500   -0.0000
    80        0.0017             nan     0.0500   -0.0000
   100        0.0009             nan     0.0500   -0.0000
   120        0.0006             nan     0.0500   -0.0000
   140        0.0004             nan     0.0500   -0.0000
   160        0.0003             nan     0.0500   -0.0000
   180        0.0002             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold27: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold27: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0418             nan     0.0500    0.0022
     2        0.0389             nan     0.0500    0.0023
     3        0.0364             nan     0.0500    0.0024
     4        0.0340             nan     0.0500    0.0023
     5        0.0331             nan     0.0500   -0.0001
     6        0.0314             nan     0.0500    0.0009
     7        0.0294             nan     0.0500    0.0020
     8        0.0275             nan     0.0500    0.0017
     9        0.0258             nan     0.0500    0.0013
    10        0.0244             nan     0.0500    0.0015
    20        0.0158             nan     0.0500    0.0007
    40        0.0082             nan     0.0500    0.0002
    60        0.0052             nan     0.0500    0.0001
    80        0.0035             nan     0.0500   -0.0000
   100        0.0025             nan     0.0500   -0.0000
   120        0.0017             nan     0.0500    0.0000
   140        0.0012             nan     0.0500   -0.0000
   160        0.0009             nan     0.0500   -0.0000
   180        0.0007             nan     0.0500   -0.0000
   200        0.0005             nan     0.0500   -0.0000

- Fold27: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold27: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0417             nan     0.0500    0.0023
     2        0.0384             nan     0.0500    0.0024
     3        0.0356             nan     0.0500    0.0016
     4        0.0327             nan     0.0500    0.0023
     5        0.0301             nan     0.0500    0.0018
     6        0.0282             nan     0.0500    0.0017
     7        0.0260             nan     0.0500    0.0010
     8        0.0242             nan     0.0500    0.0015
     9        0.0233             nan     0.0500    0.0002
    10        0.0224             nan     0.0500    0.0007
    20        0.0120             nan     0.0500    0.0009
    40        0.0039             nan     0.0500   -0.0000
    60        0.0017             nan     0.0500   -0.0000
    80        0.0008             nan     0.0500   -0.0000
   100        0.0004             nan     0.0500   -0.0000
   120        0.0002             nan     0.0500    0.0000
   140        0.0001             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500    0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold27: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold27: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0416             nan     0.0500    0.0004
     2        0.0401             nan     0.0500   -0.0005
     3        0.0386             nan     0.0500    0.0001
     4        0.0348             nan     0.0500    0.0033
     5        0.0328             nan     0.0500    0.0013
     6        0.0304             nan     0.0500    0.0019
     7        0.0284             nan     0.0500    0.0020
     8        0.0274             nan     0.0500    0.0006
     9        0.0255             nan     0.0500    0.0018
    10        0.0237             nan     0.0500    0.0016
    20        0.0120             nan     0.0500    0.0000
    40        0.0037             nan     0.0500    0.0000
    60        0.0017             nan     0.0500    0.0001
    80        0.0009             nan     0.0500   -0.0000
   100        0.0005             nan     0.0500   -0.0000
   120        0.0003             nan     0.0500   -0.0000
   140        0.0002             nan     0.0500    0.0000
   160        0.0001             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500    0.0000
   200        0.0001             nan     0.0500    0.0000

- Fold27: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold27: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0421             nan     0.0500    0.0014
     2        0.0393             nan     0.0500    0.0026
     3        0.0375             nan     0.0500    0.0023
     4        0.0360             nan     0.0500    0.0014
     5        0.0339             nan     0.0500    0.0006
     6        0.0322             nan     0.0500    0.0018
     7        0.0304             nan     0.0500    0.0008
     8        0.0285             nan     0.0500    0.0012
     9        0.0268             nan     0.0500    0.0012
    10        0.0252             nan     0.0500    0.0013
    20        0.0163             nan     0.0500    0.0001
    40        0.0081             nan     0.0500   -0.0000
    60        0.0050             nan     0.0500    0.0001
    80        0.0032             nan     0.0500    0.0001
   100        0.0024             nan     0.0500    0.0000
   120        0.0018             nan     0.0500   -0.0000
   140        0.0013             nan     0.0500    0.0000
   160        0.0009             nan     0.0500   -0.0000
   180        0.0006             nan     0.0500   -0.0000
   200        0.0004             nan     0.0500    0.0000

- Fold27: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold27: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0407             nan     0.0500    0.0022
     2        0.0395             nan     0.0500    0.0007
     3        0.0359             nan     0.0500    0.0024
     4        0.0331             nan     0.0500    0.0013
     5        0.0317             nan     0.0500    0.0014
     6        0.0298             nan     0.0500    0.0012
     7        0.0281             nan     0.0500    0.0004
     8        0.0262             nan     0.0500    0.0004
     9        0.0237             nan     0.0500    0.0015
    10        0.0220             nan     0.0500    0.0008
    20        0.0119             nan     0.0500    0.0008
    40        0.0037             nan     0.0500    0.0000
    60        0.0014             nan     0.0500    0.0000
    80        0.0006             nan     0.0500   -0.0000
   100        0.0002             nan     0.0500   -0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0000             nan     0.0500    0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500    0.0000

- Fold27: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold27: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0407             nan     0.0500    0.0038
     2        0.0376             nan     0.0500    0.0024
     3        0.0352             nan     0.0500    0.0014
     4        0.0327             nan     0.0500    0.0019
     5        0.0312             nan     0.0500    0.0010
     6        0.0287             nan     0.0500    0.0016
     7        0.0264             nan     0.0500    0.0019
     8        0.0252             nan     0.0500    0.0008
     9        0.0238             nan     0.0500    0.0017
    10        0.0225             nan     0.0500    0.0010
    20        0.0133             nan     0.0500    0.0007
    40        0.0053             nan     0.0500    0.0001
    60        0.0023             nan     0.0500    0.0001
    80        0.0009             nan     0.0500   -0.0001
   100        0.0005             nan     0.0500    0.0000
   120        0.0003             nan     0.0500   -0.0000
   140        0.0002             nan     0.0500   -0.0000
   160        0.0001             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500    0.0000

- Fold27: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold27: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0414             nan     0.0500    0.0030
     2        0.0385             nan     0.0500    0.0016
     3        0.0356             nan     0.0500    0.0014
     4        0.0338             nan     0.0500    0.0015
     5        0.0318             nan     0.0500    0.0022
     6        0.0296             nan     0.0500    0.0020
     7        0.0288             nan     0.0500   -0.0006
     8        0.0268             nan     0.0500    0.0017
     9        0.0255             nan     0.0500    0.0011
    10        0.0240             nan     0.0500    0.0012
    20        0.0149             nan     0.0500    0.0004
    40        0.0074             nan     0.0500    0.0003
    60        0.0041             nan     0.0500   -0.0001
    80        0.0025             nan     0.0500    0.0000
   100        0.0017             nan     0.0500   -0.0000
   120        0.0011             nan     0.0500    0.0000
   140        0.0007             nan     0.0500    0.0000
   160        0.0005             nan     0.0500   -0.0000
   180        0.0004             nan     0.0500   -0.0000
   200        0.0003             nan     0.0500    0.0000

- Fold27: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold27: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0371             nan     0.1000    0.0052
     2        0.0319             nan     0.1000    0.0049
     3        0.0266             nan     0.1000    0.0014
     4        0.0252             nan     0.1000    0.0011
     5        0.0230             nan     0.1000    0.0010
     6        0.0203             nan     0.1000    0.0025
     7        0.0181             nan     0.1000    0.0023
     8        0.0166             nan     0.1000    0.0018
     9        0.0153             nan     0.1000    0.0007
    10        0.0137             nan     0.1000    0.0016
    20        0.0070             nan     0.1000   -0.0000
    40        0.0018             nan     0.1000    0.0000
    60        0.0006             nan     0.1000    0.0000
    80        0.0002             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold27: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold27: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0382             nan     0.1000    0.0056
     2        0.0344             nan     0.1000    0.0015
     3        0.0295             nan     0.1000    0.0030
     4        0.0270             nan     0.1000    0.0025
     5        0.0234             nan     0.1000    0.0035
     6        0.0212             nan     0.1000    0.0004
     7        0.0197             nan     0.1000    0.0009
     8        0.0176             nan     0.1000    0.0006
     9        0.0170             nan     0.1000   -0.0003
    10        0.0151             nan     0.1000    0.0003
    20        0.0063             nan     0.1000    0.0003
    40        0.0020             nan     0.1000   -0.0002
    60        0.0009             nan     0.1000    0.0000
    80        0.0005             nan     0.1000   -0.0000
   100        0.0003             nan     0.1000    0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold27: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold27: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0427             nan     0.1000   -0.0017
     2        0.0367             nan     0.1000    0.0052
     3        0.0319             nan     0.1000    0.0042
     4        0.0298             nan     0.1000    0.0021
     5        0.0271             nan     0.1000    0.0031
     6        0.0259             nan     0.1000    0.0007
     7        0.0230             nan     0.1000    0.0028
     8        0.0208             nan     0.1000    0.0019
     9        0.0201             nan     0.1000    0.0007
    10        0.0185             nan     0.1000    0.0018
    20        0.0090             nan     0.1000   -0.0004
    40        0.0027             nan     0.1000   -0.0001
    60        0.0015             nan     0.1000    0.0001
    80        0.0007             nan     0.1000   -0.0000
   100        0.0004             nan     0.1000   -0.0000
   120        0.0003             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0002             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold27: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold27: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0386             nan     0.1000    0.0029
     2        0.0314             nan     0.1000    0.0036
     3        0.0288             nan     0.1000    0.0003
     4        0.0261             nan     0.1000    0.0020
     5        0.0223             nan     0.1000    0.0024
     6        0.0203             nan     0.1000    0.0009
     7        0.0182             nan     0.1000    0.0014
     8        0.0165             nan     0.1000    0.0005
     9        0.0140             nan     0.1000    0.0015
    10        0.0133             nan     0.1000   -0.0011
    20        0.0043             nan     0.1000   -0.0003
    40        0.0008             nan     0.1000   -0.0001
    60        0.0002             nan     0.1000    0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000    0.0000

- Fold27: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold27: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0375             nan     0.1000    0.0042
     2        0.0318             nan     0.1000    0.0057
     3        0.0276             nan     0.1000    0.0037
     4        0.0233             nan     0.1000    0.0032
     5        0.0215             nan     0.1000    0.0006
     6        0.0181             nan     0.1000    0.0021
     7        0.0164             nan     0.1000    0.0011
     8        0.0138             nan     0.1000    0.0019
     9        0.0120             nan     0.1000    0.0015
    10        0.0104             nan     0.1000    0.0016
    20        0.0034             nan     0.1000    0.0001
    40        0.0009             nan     0.1000    0.0000
    60        0.0002             nan     0.1000    0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold27: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold27: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0385             nan     0.1000    0.0036
     2        0.0340             nan     0.1000    0.0045
     3        0.0302             nan     0.1000    0.0023
     4        0.0264             nan     0.1000    0.0030
     5        0.0227             nan     0.1000    0.0034
     6        0.0200             nan     0.1000    0.0027
     7        0.0176             nan     0.1000    0.0018
     8        0.0157             nan     0.1000   -0.0003
     9        0.0140             nan     0.1000    0.0006
    10        0.0130             nan     0.1000    0.0000
    20        0.0073             nan     0.1000   -0.0004
    40        0.0032             nan     0.1000   -0.0001
    60        0.0013             nan     0.1000   -0.0001
    80        0.0007             nan     0.1000   -0.0000
   100        0.0004             nan     0.1000    0.0000
   120        0.0002             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold27: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold27: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0363             nan     0.1000    0.0093
     2        0.0304             nan     0.1000    0.0049
     3        0.0268             nan     0.1000    0.0031
     4        0.0229             nan     0.1000    0.0025
     5        0.0195             nan     0.1000    0.0012
     6        0.0186             nan     0.1000    0.0001
     7        0.0151             nan     0.1000    0.0019
     8        0.0128             nan     0.1000    0.0018
     9        0.0109             nan     0.1000    0.0009
    10        0.0089             nan     0.1000    0.0026
    20        0.0027             nan     0.1000   -0.0000
    40        0.0004             nan     0.1000   -0.0000
    60        0.0001             nan     0.1000   -0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold27: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold27: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0376             nan     0.1000    0.0057
     2        0.0330             nan     0.1000    0.0041
     3        0.0294             nan     0.1000    0.0018
     4        0.0260             nan     0.1000    0.0011
     5        0.0228             nan     0.1000    0.0001
     6        0.0197             nan     0.1000    0.0028
     7        0.0164             nan     0.1000    0.0011
     8        0.0149             nan     0.1000    0.0018
     9        0.0136             nan     0.1000    0.0012
    10        0.0127             nan     0.1000    0.0003
    20        0.0039             nan     0.1000    0.0004
    40        0.0007             nan     0.1000    0.0001
    60        0.0002             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000    0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold27: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold27: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0376             nan     0.1000    0.0050
     2        0.0328             nan     0.1000    0.0047
     3        0.0294             nan     0.1000    0.0004
     4        0.0267             nan     0.1000    0.0006
     5        0.0233             nan     0.1000    0.0029
     6        0.0205             nan     0.1000    0.0026
     7        0.0205             nan     0.1000   -0.0014
     8        0.0185             nan     0.1000    0.0020
     9        0.0164             nan     0.1000    0.0017
    10        0.0144             nan     0.1000    0.0004
    20        0.0078             nan     0.1000   -0.0006
    40        0.0026             nan     0.1000    0.0000
    60        0.0010             nan     0.1000   -0.0000
    80        0.0006             nan     0.1000   -0.0000
   100        0.0003             nan     0.1000   -0.0000
   120        0.0002             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000    0.0000
   160        0.0001             nan     0.1000    0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold27: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold28: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0406             nan     0.0100    0.0003
     2        0.0401             nan     0.0100    0.0006
     3        0.0399             nan     0.0100   -0.0001
     4        0.0396             nan     0.0100    0.0004
     5        0.0390             nan     0.0100    0.0005
     6        0.0386             nan     0.0100    0.0002
     7        0.0381             nan     0.0100    0.0004
     8        0.0375             nan     0.0100    0.0005
     9        0.0369             nan     0.0100    0.0004
    10        0.0364             nan     0.0100    0.0004
    20        0.0321             nan     0.0100    0.0004
    40        0.0260             nan     0.0100    0.0003
    60        0.0204             nan     0.0100    0.0001
    80        0.0171             nan     0.0100    0.0001
   100        0.0143             nan     0.0100    0.0001
   120        0.0119             nan     0.0100    0.0001
   140        0.0099             nan     0.0100    0.0000
   160        0.0082             nan     0.0100    0.0000
   180        0.0069             nan     0.0100   -0.0000
   200        0.0060             nan     0.0100   -0.0000

- Fold28: shrinkage=0.01, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold28: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0407             nan     0.0100    0.0003
     2        0.0402             nan     0.0100    0.0001
     3        0.0396             nan     0.0100    0.0006
     4        0.0391             nan     0.0100    0.0004
     5        0.0385             nan     0.0100    0.0005
     6        0.0379             nan     0.0100    0.0004
     7        0.0373             nan     0.0100    0.0006
     8        0.0370             nan     0.0100    0.0002
     9        0.0368             nan     0.0100   -0.0001
    10        0.0364             nan     0.0100    0.0004
    20        0.0323             nan     0.0100    0.0003
    40        0.0258             nan     0.0100   -0.0000
    60        0.0213             nan     0.0100    0.0002
    80        0.0176             nan     0.0100    0.0001
   100        0.0147             nan     0.0100    0.0000
   120        0.0128             nan     0.0100    0.0001
   140        0.0108             nan     0.0100    0.0000
   160        0.0091             nan     0.0100    0.0000
   180        0.0077             nan     0.0100    0.0000
   200        0.0066             nan     0.0100    0.0000

- Fold28: shrinkage=0.01, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold28: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0404             nan     0.0100    0.0006
     2        0.0397             nan     0.0100    0.0006
     3        0.0392             nan     0.0100    0.0005
     4        0.0391             nan     0.0100   -0.0002
     5        0.0385             nan     0.0100    0.0004
     6        0.0379             nan     0.0100    0.0002
     7        0.0375             nan     0.0100    0.0004
     8        0.0371             nan     0.0100    0.0002
     9        0.0367             nan     0.0100    0.0004
    10        0.0361             nan     0.0100    0.0005
    20        0.0321             nan     0.0100    0.0004
    40        0.0262             nan     0.0100    0.0000
    60        0.0219             nan     0.0100    0.0001
    80        0.0182             nan     0.0100    0.0001
   100        0.0159             nan     0.0100    0.0001
   120        0.0135             nan     0.0100    0.0000
   140        0.0117             nan     0.0100   -0.0000
   160        0.0107             nan     0.0100   -0.0001
   180        0.0097             nan     0.0100    0.0000
   200        0.0087             nan     0.0100   -0.0000

- Fold28: shrinkage=0.01, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold28: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0405             nan     0.0100    0.0004
     2        0.0397             nan     0.0100    0.0010
     3        0.0390             nan     0.0100    0.0006
     4        0.0386             nan     0.0100    0.0002
     5        0.0381             nan     0.0100    0.0004
     6        0.0374             nan     0.0100    0.0009
     7        0.0369             nan     0.0100    0.0004
     8        0.0363             nan     0.0100    0.0005
     9        0.0359             nan     0.0100    0.0002
    10        0.0354             nan     0.0100    0.0005
    20        0.0310             nan     0.0100    0.0002
    40        0.0233             nan     0.0100    0.0003
    60        0.0181             nan     0.0100    0.0001
    80        0.0140             nan     0.0100    0.0001
   100        0.0110             nan     0.0100    0.0001
   120        0.0089             nan     0.0100    0.0000
   140        0.0070             nan     0.0100    0.0000
   160        0.0056             nan     0.0100    0.0000
   180        0.0045             nan     0.0100    0.0000
   200        0.0037             nan     0.0100    0.0000

- Fold28: shrinkage=0.01, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold28: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0407             nan     0.0100    0.0002
     2        0.0399             nan     0.0100    0.0004
     3        0.0394             nan     0.0100    0.0005
     4        0.0388             nan     0.0100    0.0004
     5        0.0383             nan     0.0100    0.0005
     6        0.0377             nan     0.0100    0.0005
     7        0.0371             nan     0.0100    0.0004
     8        0.0368             nan     0.0100    0.0003
     9        0.0362             nan     0.0100    0.0004
    10        0.0358             nan     0.0100    0.0004
    20        0.0319             nan     0.0100    0.0001
    40        0.0253             nan     0.0100    0.0002
    60        0.0202             nan     0.0100    0.0002
    80        0.0161             nan     0.0100    0.0002
   100        0.0128             nan     0.0100    0.0001
   120        0.0103             nan     0.0100   -0.0000
   140        0.0086             nan     0.0100    0.0001
   160        0.0070             nan     0.0100    0.0000
   180        0.0058             nan     0.0100    0.0000
   200        0.0049             nan     0.0100    0.0000

- Fold28: shrinkage=0.01, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold28: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0408             nan     0.0100    0.0000
     2        0.0403             nan     0.0100    0.0002
     3        0.0397             nan     0.0100    0.0003
     4        0.0394             nan     0.0100   -0.0001
     5        0.0389             nan     0.0100    0.0005
     6        0.0385             nan     0.0100    0.0001
     7        0.0381             nan     0.0100    0.0004
     8        0.0376             nan     0.0100    0.0003
     9        0.0372             nan     0.0100    0.0002
    10        0.0367             nan     0.0100    0.0004
    20        0.0332             nan     0.0100    0.0004
    40        0.0270             nan     0.0100    0.0003
    60        0.0222             nan     0.0100    0.0001
    80        0.0184             nan     0.0100    0.0000
   100        0.0153             nan     0.0100    0.0000
   120        0.0135             nan     0.0100   -0.0000
   140        0.0119             nan     0.0100    0.0000
   160        0.0107             nan     0.0100   -0.0000
   180        0.0096             nan     0.0100    0.0001
   200        0.0084             nan     0.0100   -0.0000

- Fold28: shrinkage=0.01, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold28: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0407             nan     0.0100    0.0002
     2        0.0399             nan     0.0100    0.0007
     3        0.0393             nan     0.0100    0.0005
     4        0.0387             nan     0.0100    0.0005
     5        0.0381             nan     0.0100    0.0004
     6        0.0377             nan     0.0100    0.0005
     7        0.0374             nan     0.0100    0.0003
     8        0.0369             nan     0.0100    0.0004
     9        0.0364             nan     0.0100    0.0002
    10        0.0359             nan     0.0100    0.0004
    20        0.0312             nan     0.0100    0.0000
    40        0.0234             nan     0.0100    0.0003
    60        0.0178             nan     0.0100    0.0002
    80        0.0142             nan     0.0100    0.0001
   100        0.0110             nan     0.0100    0.0001
   120        0.0084             nan     0.0100    0.0001
   140        0.0068             nan     0.0100    0.0001
   160        0.0053             nan     0.0100    0.0000
   180        0.0044             nan     0.0100    0.0000
   200        0.0035             nan     0.0100   -0.0001

- Fold28: shrinkage=0.01, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold28: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0406             nan     0.0100    0.0005
     2        0.0398             nan     0.0100    0.0003
     3        0.0396             nan     0.0100    0.0001
     4        0.0390             nan     0.0100    0.0005
     5        0.0387             nan     0.0100    0.0002
     6        0.0382             nan     0.0100   -0.0000
     7        0.0375             nan     0.0100    0.0006
     8        0.0371             nan     0.0100    0.0003
     9        0.0364             nan     0.0100    0.0004
    10        0.0361             nan     0.0100    0.0001
    20        0.0316             nan     0.0100    0.0002
    40        0.0248             nan     0.0100    0.0001
    60        0.0199             nan     0.0100    0.0000
    80        0.0153             nan     0.0100    0.0001
   100        0.0123             nan     0.0100    0.0001
   120        0.0101             nan     0.0100    0.0001
   140        0.0084             nan     0.0100    0.0000
   160        0.0068             nan     0.0100   -0.0000
   180        0.0055             nan     0.0100    0.0000
   200        0.0047             nan     0.0100   -0.0000

- Fold28: shrinkage=0.01, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold28: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0405             nan     0.0100    0.0004
     2        0.0400             nan     0.0100    0.0004
     3        0.0395             nan     0.0100    0.0005
     4        0.0390             nan     0.0100    0.0003
     5        0.0384             nan     0.0100    0.0006
     6        0.0378             nan     0.0100    0.0000
     7        0.0375             nan     0.0100    0.0004
     8        0.0371             nan     0.0100    0.0000
     9        0.0368             nan     0.0100    0.0002
    10        0.0364             nan     0.0100    0.0003
    20        0.0322             nan     0.0100    0.0004
    40        0.0264             nan     0.0100    0.0001
    60        0.0219             nan     0.0100    0.0001
    80        0.0184             nan     0.0100    0.0002
   100        0.0155             nan     0.0100    0.0001
   120        0.0133             nan     0.0100    0.0001
   140        0.0117             nan     0.0100    0.0000
   160        0.0103             nan     0.0100    0.0000
   180        0.0091             nan     0.0100    0.0000
   200        0.0083             nan     0.0100    0.0000

- Fold28: shrinkage=0.01, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold28: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0390             nan     0.0500    0.0015
     2        0.0369             nan     0.0500    0.0018
     3        0.0344             nan     0.0500    0.0024
     4        0.0319             nan     0.0500    0.0019
     5        0.0308             nan     0.0500    0.0006
     6        0.0288             nan     0.0500    0.0015
     7        0.0276             nan     0.0500    0.0004
     8        0.0260             nan     0.0500    0.0008
     9        0.0245             nan     0.0500    0.0013
    10        0.0230             nan     0.0500    0.0015
    20        0.0143             nan     0.0500    0.0005
    40        0.0063             nan     0.0500    0.0000
    60        0.0031             nan     0.0500   -0.0000
    80        0.0015             nan     0.0500   -0.0001
   100        0.0009             nan     0.0500   -0.0000
   120        0.0005             nan     0.0500    0.0000
   140        0.0003             nan     0.0500    0.0000
   160        0.0002             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500    0.0000
   200        0.0001             nan     0.0500   -0.0000

- Fold28: shrinkage=0.05, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold28: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0390             nan     0.0500    0.0025
     2        0.0363             nan     0.0500    0.0025
     3        0.0339             nan     0.0500    0.0024
     4        0.0321             nan     0.0500    0.0020
     5        0.0309             nan     0.0500    0.0009
     6        0.0297             nan     0.0500    0.0013
     7        0.0282             nan     0.0500    0.0013
     8        0.0273             nan     0.0500    0.0004
     9        0.0261             nan     0.0500    0.0013
    10        0.0244             nan     0.0500    0.0010
    20        0.0156             nan     0.0500    0.0001
    40        0.0072             nan     0.0500    0.0003
    60        0.0035             nan     0.0500    0.0000
    80        0.0020             nan     0.0500    0.0000
   100        0.0012             nan     0.0500    0.0000
   120        0.0008             nan     0.0500   -0.0000
   140        0.0005             nan     0.0500   -0.0000
   160        0.0003             nan     0.0500   -0.0000
   180        0.0002             nan     0.0500    0.0000
   200        0.0001             nan     0.0500    0.0000

- Fold28: shrinkage=0.05, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold28: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0380             nan     0.0500    0.0027
     2        0.0361             nan     0.0500    0.0020
     3        0.0342             nan     0.0500    0.0013
     4        0.0327             nan     0.0500    0.0014
     5        0.0311             nan     0.0500    0.0018
     6        0.0303             nan     0.0500    0.0001
     7        0.0287             nan     0.0500    0.0010
     8        0.0274             nan     0.0500    0.0016
     9        0.0255             nan     0.0500    0.0011
    10        0.0242             nan     0.0500    0.0002
    20        0.0157             nan     0.0500    0.0003
    40        0.0081             nan     0.0500    0.0003
    60        0.0053             nan     0.0500   -0.0001
    80        0.0039             nan     0.0500   -0.0001
   100        0.0027             nan     0.0500    0.0000
   120        0.0018             nan     0.0500   -0.0000
   140        0.0014             nan     0.0500    0.0000
   160        0.0011             nan     0.0500   -0.0000
   180        0.0008             nan     0.0500    0.0000
   200        0.0007             nan     0.0500   -0.0000

- Fold28: shrinkage=0.05, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold28: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0373             nan     0.0500    0.0015
     2        0.0366             nan     0.0500   -0.0007
     3        0.0348             nan     0.0500    0.0013
     4        0.0322             nan     0.0500    0.0021
     5        0.0297             nan     0.0500    0.0018
     6        0.0279             nan     0.0500    0.0003
     7        0.0266             nan     0.0500    0.0012
     8        0.0250             nan     0.0500   -0.0004
     9        0.0230             nan     0.0500    0.0003
    10        0.0223             nan     0.0500   -0.0008
    20        0.0128             nan     0.0500    0.0004
    40        0.0041             nan     0.0500    0.0000
    60        0.0015             nan     0.0500    0.0000
    80        0.0007             nan     0.0500    0.0000
   100        0.0004             nan     0.0500   -0.0000
   120        0.0002             nan     0.0500   -0.0000
   140        0.0001             nan     0.0500    0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500   -0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold28: shrinkage=0.05, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold28: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0375             nan     0.0500    0.0027
     2        0.0351             nan     0.0500    0.0020
     3        0.0328             nan     0.0500    0.0019
     4        0.0304             nan     0.0500    0.0016
     5        0.0281             nan     0.0500    0.0009
     6        0.0261             nan     0.0500    0.0014
     7        0.0246             nan     0.0500    0.0011
     8        0.0226             nan     0.0500    0.0006
     9        0.0220             nan     0.0500    0.0004
    10        0.0205             nan     0.0500    0.0010
    20        0.0116             nan     0.0500    0.0002
    40        0.0049             nan     0.0500    0.0001
    60        0.0023             nan     0.0500    0.0000
    80        0.0011             nan     0.0500   -0.0000
   100        0.0006             nan     0.0500    0.0000
   120        0.0004             nan     0.0500    0.0000
   140        0.0002             nan     0.0500   -0.0000
   160        0.0001             nan     0.0500   -0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500    0.0000

- Fold28: shrinkage=0.05, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold28: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0386             nan     0.0500    0.0017
     2        0.0373             nan     0.0500    0.0008
     3        0.0349             nan     0.0500    0.0006
     4        0.0331             nan     0.0500    0.0015
     5        0.0312             nan     0.0500    0.0008
     6        0.0295             nan     0.0500    0.0017
     7        0.0281             nan     0.0500    0.0010
     8        0.0267             nan     0.0500    0.0013
     9        0.0251             nan     0.0500    0.0014
    10        0.0244             nan     0.0500    0.0001
    20        0.0167             nan     0.0500    0.0003
    40        0.0092             nan     0.0500   -0.0001
    60        0.0061             nan     0.0500    0.0000
    80        0.0042             nan     0.0500   -0.0000
   100        0.0027             nan     0.0500    0.0000
   120        0.0020             nan     0.0500   -0.0000
   140        0.0012             nan     0.0500    0.0000
   160        0.0009             nan     0.0500    0.0000
   180        0.0007             nan     0.0500   -0.0000
   200        0.0005             nan     0.0500   -0.0000

- Fold28: shrinkage=0.05, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold28: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0371             nan     0.0500    0.0049
     2        0.0350             nan     0.0500    0.0009
     3        0.0320             nan     0.0500    0.0024
     4        0.0301             nan     0.0500    0.0014
     5        0.0279             nan     0.0500    0.0003
     6        0.0269             nan     0.0500    0.0000
     7        0.0252             nan     0.0500    0.0012
     8        0.0234             nan     0.0500    0.0017
     9        0.0215             nan     0.0500    0.0010
    10        0.0202             nan     0.0500    0.0014
    20        0.0102             nan     0.0500    0.0002
    40        0.0032             nan     0.0500    0.0000
    60        0.0013             nan     0.0500   -0.0000
    80        0.0006             nan     0.0500    0.0000
   100        0.0002             nan     0.0500   -0.0000
   120        0.0001             nan     0.0500   -0.0000
   140        0.0000             nan     0.0500   -0.0000
   160        0.0000             nan     0.0500   -0.0000
   180        0.0000             nan     0.0500    0.0000
   200        0.0000             nan     0.0500   -0.0000

- Fold28: shrinkage=0.05, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold28: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0384             nan     0.0500    0.0022
     2        0.0353             nan     0.0500    0.0026
     3        0.0320             nan     0.0500    0.0029
     4        0.0295             nan     0.0500    0.0020
     5        0.0273             nan     0.0500    0.0021
     6        0.0259             nan     0.0500    0.0011
     7        0.0242             nan     0.0500    0.0012
     8        0.0226             nan     0.0500    0.0015
     9        0.0209             nan     0.0500    0.0018
    10        0.0194             nan     0.0500    0.0009
    20        0.0112             nan     0.0500    0.0003
    40        0.0041             nan     0.0500   -0.0000
    60        0.0017             nan     0.0500    0.0000
    80        0.0009             nan     0.0500   -0.0000
   100        0.0005             nan     0.0500    0.0000
   120        0.0003             nan     0.0500   -0.0000
   140        0.0002             nan     0.0500   -0.0000
   160        0.0001             nan     0.0500    0.0000
   180        0.0001             nan     0.0500   -0.0000
   200        0.0001             nan     0.0500    0.0000

- Fold28: shrinkage=0.05, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold28: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0385             nan     0.0500    0.0020
     2        0.0374             nan     0.0500    0.0007
     3        0.0362             nan     0.0500   -0.0002
     4        0.0346             nan     0.0500    0.0015
     5        0.0334             nan     0.0500   -0.0003
     6        0.0311             nan     0.0500    0.0018
     7        0.0306             nan     0.0500    0.0001
     8        0.0290             nan     0.0500    0.0011
     9        0.0269             nan     0.0500    0.0008
    10        0.0263             nan     0.0500    0.0005
    20        0.0174             nan     0.0500    0.0008
    40        0.0092             nan     0.0500    0.0002
    60        0.0058             nan     0.0500   -0.0001
    80        0.0040             nan     0.0500   -0.0001
   100        0.0030             nan     0.0500   -0.0000
   120        0.0021             nan     0.0500    0.0000
   140        0.0015             nan     0.0500   -0.0000
   160        0.0011             nan     0.0500   -0.0000
   180        0.0008             nan     0.0500    0.0000
   200        0.0007             nan     0.0500   -0.0000

- Fold28: shrinkage=0.05, interaction.depth=3, n.minobsinnode=5, n.trees=200 
+ Fold28: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0353             nan     0.1000    0.0051
     2        0.0318             nan     0.1000    0.0043
     3        0.0284             nan     0.1000    0.0027
     4        0.0259             nan     0.1000    0.0028
     5        0.0234             nan     0.1000    0.0027
     6        0.0204             nan     0.1000    0.0021
     7        0.0199             nan     0.1000   -0.0010
     8        0.0177             nan     0.1000    0.0021
     9        0.0160             nan     0.1000    0.0001
    10        0.0141             nan     0.1000    0.0023
    20        0.0076             nan     0.1000    0.0008
    40        0.0023             nan     0.1000   -0.0001
    60        0.0008             nan     0.1000   -0.0001
    80        0.0003             nan     0.1000   -0.0000
   100        0.0001             nan     0.1000    0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold28: shrinkage=0.10, interaction.depth=1, n.minobsinnode=1, n.trees=200 
+ Fold28: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0349             nan     0.1000    0.0051
     2        0.0309             nan     0.1000    0.0042
     3        0.0291             nan     0.1000    0.0018
     4        0.0263             nan     0.1000    0.0020
     5        0.0230             nan     0.1000    0.0025
     6        0.0199             nan     0.1000    0.0030
     7        0.0182             nan     0.1000    0.0003
     8        0.0158             nan     0.1000    0.0011
     9        0.0141             nan     0.1000    0.0013
    10        0.0138             nan     0.1000    0.0001
    20        0.0062             nan     0.1000    0.0000
    40        0.0023             nan     0.1000   -0.0000
    60        0.0008             nan     0.1000   -0.0000
    80        0.0004             nan     0.1000    0.0000
   100        0.0002             nan     0.1000   -0.0000
   120        0.0001             nan     0.1000    0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000    0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold28: shrinkage=0.10, interaction.depth=1, n.minobsinnode=3, n.trees=200 
+ Fold28: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0347             nan     0.1000    0.0051
     2        0.0314             nan     0.1000    0.0013
     3        0.0283             nan     0.1000    0.0027
     4        0.0260             nan     0.1000    0.0000
     5        0.0235             nan     0.1000    0.0018
     6        0.0210             nan     0.1000    0.0019
     7        0.0184             nan     0.1000    0.0019
     8        0.0172             nan     0.1000    0.0011
     9        0.0155             nan     0.1000    0.0013
    10        0.0142             nan     0.1000    0.0012
    20        0.0084             nan     0.1000    0.0001
    40        0.0037             nan     0.1000    0.0001
    60        0.0023             nan     0.1000    0.0000
    80        0.0013             nan     0.1000   -0.0001
   100        0.0008             nan     0.1000   -0.0000
   120        0.0005             nan     0.1000    0.0000
   140        0.0003             nan     0.1000   -0.0000
   160        0.0003             nan     0.1000   -0.0000
   180        0.0002             nan     0.1000    0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold28: shrinkage=0.10, interaction.depth=1, n.minobsinnode=5, n.trees=200 
+ Fold28: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0392             nan     0.1000   -0.0004
     2        0.0358             nan     0.1000    0.0029
     3        0.0298             nan     0.1000    0.0026
     4        0.0253             nan     0.1000    0.0046
     5        0.0201             nan     0.1000    0.0046
     6        0.0172             nan     0.1000    0.0023
     7        0.0161             nan     0.1000    0.0004
     8        0.0159             nan     0.1000   -0.0006
     9        0.0153             nan     0.1000    0.0001
    10        0.0140             nan     0.1000    0.0002
    20        0.0047             nan     0.1000    0.0005
    40        0.0007             nan     0.1000    0.0000
    60        0.0002             nan     0.1000   -0.0000
    80        0.0001             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000    0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold28: shrinkage=0.10, interaction.depth=2, n.minobsinnode=1, n.trees=200 
+ Fold28: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0371             nan     0.1000    0.0021
     2        0.0338             nan     0.1000    0.0035
     3        0.0298             nan     0.1000    0.0041
     4        0.0281             nan     0.1000    0.0001
     5        0.0238             nan     0.1000    0.0007
     6        0.0208             nan     0.1000    0.0021
     7        0.0171             nan     0.1000    0.0013
     8        0.0147             nan     0.1000    0.0013
     9        0.0140             nan     0.1000    0.0003
    10        0.0122             nan     0.1000   -0.0001
    20        0.0051             nan     0.1000   -0.0000
    40        0.0012             nan     0.1000    0.0000
    60        0.0006             nan     0.1000    0.0000
    80        0.0003             nan     0.1000   -0.0000
   100        0.0002             nan     0.1000   -0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold28: shrinkage=0.10, interaction.depth=2, n.minobsinnode=3, n.trees=200 
+ Fold28: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0375             nan     0.1000    0.0028
     2        0.0322             nan     0.1000    0.0051
     3        0.0293             nan     0.1000    0.0030
     4        0.0262             nan     0.1000    0.0030
     5        0.0238             nan     0.1000    0.0017
     6        0.0215             nan     0.1000    0.0012
     7        0.0188             nan     0.1000    0.0021
     8        0.0167             nan     0.1000    0.0018
     9        0.0152             nan     0.1000    0.0011
    10        0.0138             nan     0.1000    0.0003
    20        0.0064             nan     0.1000    0.0002
    40        0.0026             nan     0.1000   -0.0001
    60        0.0013             nan     0.1000    0.0000
    80        0.0008             nan     0.1000    0.0000
   100        0.0004             nan     0.1000   -0.0000
   120        0.0002             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000    0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0001             nan     0.1000   -0.0000

- Fold28: shrinkage=0.10, interaction.depth=2, n.minobsinnode=5, n.trees=200 
+ Fold28: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0340             nan     0.1000    0.0058
     2        0.0291             nan     0.1000    0.0048
     3        0.0267             nan     0.1000    0.0004
     4        0.0215             nan     0.1000    0.0048
     5        0.0194             nan     0.1000    0.0011
     6        0.0173             nan     0.1000    0.0009
     7        0.0146             nan     0.1000    0.0028
     8        0.0120             nan     0.1000    0.0021
     9        0.0109             nan     0.1000   -0.0000
    10        0.0089             nan     0.1000    0.0019
    20        0.0032             nan     0.1000   -0.0002
    40        0.0005             nan     0.1000   -0.0001
    60        0.0001             nan     0.1000   -0.0000
    80        0.0000             nan     0.1000   -0.0000
   100        0.0000             nan     0.1000   -0.0000
   120        0.0000             nan     0.1000   -0.0000
   140        0.0000             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold28: shrinkage=0.10, interaction.depth=3, n.minobsinnode=1, n.trees=200 
+ Fold28: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0360             nan     0.1000    0.0057
     2        0.0332             nan     0.1000    0.0004
     3        0.0299             nan     0.1000   -0.0013
     4        0.0271             nan     0.1000    0.0030
     5        0.0237             nan     0.1000    0.0022
     6        0.0198             nan     0.1000    0.0028
     7        0.0165             nan     0.1000    0.0012
     8        0.0148             nan     0.1000    0.0020
     9        0.0137             nan     0.1000    0.0004
    10        0.0123             nan     0.1000    0.0012
    20        0.0062             nan     0.1000   -0.0004
    40        0.0023             nan     0.1000   -0.0002
    60        0.0011             nan     0.1000    0.0001
    80        0.0006             nan     0.1000   -0.0000
   100        0.0003             nan     0.1000    0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold28: shrinkage=0.10, interaction.depth=3, n.minobsinnode=3, n.trees=200 
+ Fold28: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0362             nan     0.1000    0.0032
     2        0.0318             nan     0.1000    0.0013
     3        0.0272             nan     0.1000    0.0041
     4        0.0246             nan     0.1000    0.0031
     5        0.0231             nan     0.1000    0.0014
     6        0.0204             nan     0.1000    0.0004
     7        0.0183             nan     0.1000    0.0016
     8        0.0178             nan     0.1000    0.0004
     9        0.0160             nan     0.1000    0.0008
    10        0.0149             nan     0.1000    0.0008
    20        0.0077             nan     0.1000    0.0002
    40        0.0026             nan     0.1000   -0.0000
    60        0.0012             nan     0.1000   -0.0000
    80        0.0007             nan     0.1000    0.0000
   100        0.0003             nan     0.1000    0.0000
   120        0.0003             nan     0.1000   -0.0000
   140        0.0002             nan     0.1000    0.0000
   160        0.0001             nan     0.1000   -0.0000
   180        0.0001             nan     0.1000   -0.0000
   200        0.0000             nan     0.1000   -0.0000

- Fold28: shrinkage=0.10, interaction.depth=3, n.minobsinnode=5, n.trees=200 
Aggregating results
Selecting tuning parameters
Fitting n.trees = 200, interaction.depth = 1, shrinkage = 0.1, n.minobsinnode = 3 on full training set
Iter   TrainDeviance   ValidDeviance   StepSize   Improve
     1        0.0378             nan     0.1000    0.0055
     2        0.0330             nan     0.1000    0.0041
     3        0.0290             nan     0.1000    0.0037
     4        0.0267             nan     0.1000    0.0013
     5        0.0239             nan     0.1000    0.0029
     6        0.0214             nan     0.1000    0.0027
     7        0.0196             nan     0.1000    0.0021
     8        0.0170             nan     0.1000    0.0020
     9        0.0155             nan     0.1000    0.0015
    10        0.0151             nan     0.1000   -0.0014
    20        0.0072             nan     0.1000   -0.0001
    40        0.0020             nan     0.1000    0.0000
    60        0.0011             nan     0.1000    0.0000
    80        0.0005             nan     0.1000    0.0000
   100        0.0002             nan     0.1000   -0.0000
   120        0.0001             nan     0.1000   -0.0000
   140        0.0001             nan     0.1000   -0.0000
   160        0.0000             nan     0.1000   -0.0000
   180        0.0000             nan     0.1000    0.0000
   200        0.0000             nan     0.1000   -0.0000

Comparing predictions

elastic_pred <- predict(elastic_net_model, data_aggr)
rf_pred <- predict(rf_model, data_aggr)
gbm_pred <- predict(gbm_model, data_aggr)

# Actual values
actual <- data_aggr$mean_trans_docs

# Create a data frame with all predictions and actual values
all_predictions <- data.frame(
  country = data_aggr$country,
  actual = actual,
  elastic_net = elastic_pred,
  random_forest = rf_pred,
  gradient_boosting = gbm_pred
)

# Calculate errors for each model
all_predictions$elastic_error <- abs(all_predictions$actual - all_predictions$elastic_net)
all_predictions$rf_error <- abs(all_predictions$actual - all_predictions$random_forest)
all_predictions$gbm_error <- abs(all_predictions$actual - all_predictions$gradient_boosting)

# Calculate performance metrics for each model
calculate_metrics <- function(actual, predicted) {
  residuals <- actual - predicted
  r_squared <- 1 - sum(residuals^2) / sum((actual - mean(actual))^2)
  rmse <- sqrt(mean(residuals^2))
  mae <- mean(abs(residuals))
  
  return(c(R_squared = r_squared, RMSE = rmse, MAE = mae))
}

# Get metrics for each model
elastic_metrics <- calculate_metrics(actual, elastic_pred)
rf_metrics <- calculate_metrics(actual, rf_pred)
gbm_metrics <- calculate_metrics(actual, gbm_pred)

# Combine metrics
model_metrics <- rbind(
  Elastic_Net = elastic_metrics,
  Random_Forest = rf_metrics,
  Gradient_Boosting = gbm_metrics
)

# Print performance comparison
print(model_metrics)
                  R_squared        RMSE         MAE
Elastic_Net       0.9469052 0.047712555 0.040121652
Random_Forest     0.9624421 0.040128869 0.033077032
Gradient_Boosting 0.9998393 0.002624701 0.001677268
# Sort predictions by actual values (descending)
sorted_predictions <- all_predictions[order(all_predictions$actual, decreasing = TRUE), ]

# Print sorted predictions
print(sorted_predictions[, c("country", "actual", "elastic_net", "random_forest", "gradient_boosting")])
   country    actual elastic_net random_forest gradient_boosting
9       ES 0.9033659   0.8524193     0.8229980         0.8943799
22      NL 0.8663265   0.8423528     0.8282076         0.8654335
21      MT 0.8526786   0.8221836     0.8044864         0.8553885
7       DK 0.7967742   0.7403161     0.7668226         0.7955572
6       DE 0.7906977   0.7787671     0.7752393         0.7907475
11      FR 0.7901639   0.7352544     0.7787188         0.7894155
19      LU 0.7884615   0.7664504     0.7721643         0.7896432
24      PT 0.7749726   0.6632592     0.7435922         0.7750610
16      IE 0.7324263   0.7264290     0.7310612         0.7321643
2       BE 0.7278107   0.7260266     0.6970312         0.7274396
26      SE 0.7217295   0.7265787     0.7351573         0.7225695
10      FI 0.7100793   0.7267072     0.7283696         0.7098319
12      GB 0.7014428   0.7396484     0.7283549         0.7049659
1       AT 0.6154650   0.6371225     0.6489905         0.6163184
8       EE 0.6127024   0.5584945     0.5657370         0.6109038
13      GR 0.5980498   0.6064764     0.5695054         0.5978351
4       CY 0.5388471   0.5638382     0.5222309         0.5388480
27      SI 0.5282609   0.5777653     0.5664119         0.5288987
23      PL 0.5000000   0.4459348     0.4484063         0.4956427
20      LV 0.4840614   0.4266426     0.4447476         0.4815411
17      IT 0.4769404   0.5510112     0.5087186         0.4748203
14      HR 0.4539474   0.5159239     0.4814678         0.4538986
5       CZ 0.4472252   0.4214334     0.4667415         0.4484678
18      LT 0.4265570   0.4801427     0.4400768         0.4282762
28      SK 0.2990971   0.3362504     0.2958200         0.2984954
25      RO 0.2386740   0.2716489     0.2695934         0.2385616
3       BG 0.1666667   0.2572985     0.2623803         0.1724222
15      HU 0.1594684   0.2065162     0.2466841         0.1633312
# Visualize predictions across countries
# Reshape the data for plotting

plot_data <- sorted_predictions %>%
  select(country, actual, elastic_net, random_forest, gradient_boosting) %>%
  gather(key = "model", value = "prediction", -country, -actual)

# Create plot
ggplot(plot_data, aes(x = reorder(country, -actual), y = prediction, fill = model)) +
  geom_bar(stat = "identity", position = position_dodge()) +
  geom_point(aes(y = actual), color = "black", size = 2) +
  theme_minimal() +
  theme(axis.text.x = element_text(angle = 90, hjust = 1)) +
  labs(title = "Model Predictions vs Actual Values by Country",
       x = "Country", y = "Proportion Supporting Trans Document Changes") +
  scale_fill_brewer(palette = "Set1")
# Create a scatterplot of actual vs predicted for each model
ggplot(plot_data, aes(x = actual, y = prediction, color = model)) +
  geom_point(size = 3, alpha = 0.7) +
  geom_abline(intercept = 0, slope = 1, linetype = "dashed") +
  facet_wrap(~model) +
  theme_minimal() +
  labs(title = "Actual vs Predicted Values by Model",
       x = "Actual Values", y = "Predicted Values")
# Find which model performed best for each country
all_predictions$best_model <- apply(all_predictions[, c("elastic_error", "rf_error", "gbm_error")], 1, 
                                   function(x) c("Elastic Net", "Random Forest", "Gradient Boosting")[which.min(x)])

# Count how many countries each model performed best on
table(all_predictions$best_model)

Gradient Boosting 
               28 
Checks for overfitting in GBM:
# Calculate residuals
gbm_residuals <- actual - gbm_pred

# Create a dataframe
residuals_df <- data.frame(actual, gbm_residuals)

# Plot residuals
ggplot(residuals_df, aes(x = actual, y = gbm_residuals)) +
  geom_point(color = "red", alpha = 0.7) +
  geom_hline(yintercept = 0, linetype = "dashed") +
  theme_minimal() +
  labs(title = "Residuals Plot for Gradient Boosting",
       x = "Actual Values", y = "Residuals")
library(gbm)
gbm_importance <- varImp(gbm_model, scale = FALSE)

# Plot importance
ggplot(gbm_importance, aes(x = reorder(rownames(gbm_importance), Overall), y = Overall)) +
  geom_col(fill = "blue") +
  coord_flip() +
  theme_minimal() +
  labs(title = "Feature Importance - Gradient Boosting",
       x = "Features", y = "Importance")
gbm_importance
gbm variable importance

  only 20 most important variables shown (out of 77)

                                               Overall
democracy_index                                0.71634
mean_antilgbtq_rights                          0.63375
`friends_trans_Refusal (SPONTANEOUS)`          0.36218
mean_gender_docs                               0.35293
`marital_status_Single (9-10 in d7)`           0.18382
mean_minority_discri                           0.17790
mean_years_edu                                 0.14287
`occupation_Students (2 in d15a)`              0.14179
mean_roma_minority                             0.11544
gdp_pc_ppp                                     0.10356
`phone_access_No telephone`                    0.09767
`phone_access_Mobile only`                     0.08173
`occupation_Managers (10 to 12 in d15a)`       0.07732
`occupation_Manual workers (15 to 18 in d15a)` 0.06055
`life_sat_Not very satisfied`                  0.05583
`left_right_(7 -10) Right`                     0.05401
`occupation_Unemployed (3 in d15a)`            0.05084
`occupation_House persons (1 in d15a)`         0.05031
`life_sat_Not at all satisfied`                0.04963
`left_right_(1 - 4) Left`                      0.03986

Brad’s theory notes

Leaving this section here, it is to be deleted as we incorporate what we need from here into the explanatory model part

Running a different logistic model for each country

We now have a table to test some glmer modelling on.

Following this tutorial Marga sent and applying to the test data:

https://raffaelevacca.github.io/Intro-multilevel-with-R/

Testing a nested dataset by country

# Commented the below as we are probably not gonna use it
# 
# nested.cntry <- complete_df %>%
#   group_by(country) %>%
#   nest()
# 
# # The column nested.df$data is a list of data frames, one for each country
# class(nested.cntry$data) # type, list
# length(nested.cntry$data) # number of countries
# 
# # to unnest()
# nested.cntry %>%
#   filter(country == "AT") %>%
#   dplyr::select(country, data) %>%
#   unnest(cols = c(data))

# # Using the nested data, we now run a model for each country:

# # fit separate lm for each each element of nested.cntry$data)
# lmodels <- nested.cntry %>%
#   # Get all data frames
#   pull(data) %>%
#   # Run glm() on each via map because it's a classification model
#     # model run against all vairables for now. 
#   purrr::map(~ glm(trans_docs ~ ., 
#                    data= .x,
#                    family = "binomial"))
# 
# # show that it's a list and we can call each elements regression output. 
# class(lmodels)
# lmodels[4]

Mixed models

Fixed effects: Things that are the same across the cluster Random effects: Things that change within the cluster

The fixed and random effects could refer to either the intercept or the slope, as these can both vary between groups.

LMM equation structure in R

To run a multilevel linear model, we use the lmer() function (“Linear Mixed Effects in R”) from the lme4 package. The syntax is similar to regression. everything to the left of the | indicates the effects that should be random, and the variable to the right of the | is the grouping variable across which the effects should vary

Null model This has no slope, but random intercepts. It basically just takes the average. It has no independent (X) variables and is the proper naïve model.

null_model <- lmer(Y ~ (1|cntry), data = ess)

Random intercept model: –> Only the intercept differ. The slopes are equal for each group. We assume the same effect of X on Y for each group. Just that the group causes the difference.

random_int_model <- lmer(Y ~ X + (1 | group), data=df)

Random intercept, random slope model –> Now we also let the slope vary by group. This means each group basically has it’s own model. It is

random_intslope_model <- lmer(Y ~ X + (X | group), data=df)

For each, Y=target, X = independent vars (can be many)

Standard LMM Modelling Strategy

(sourced from slides here: https://favstats.github.io/intro_multilevel/slides/#54) ^ This is a useful resource, it goes through an ESS modelling doc

Approach to multilevel model building based on Hox (2010)

1/ Null Model (Random Intercept only) 2/ Add independent Level 1 variables 3/ Add independent Level 2 variables 4/ Add random slopes 5/ (Cross-level) interactions

Each step, check whether your model is significantly improved compared to the previous one.

Basic LMM testing with toy data

First, null model:

# m_null <- glmer(trans_docs ~ (1|country),
#                data = complete_df,
#                family = "binomial",
#                control = glmerControl(optimizer = "bobyqa"),
#                nAGQ = 10)
# summary(m_null)

To come back and reinterpret… don’t really know at this stage.

Test flexplot and broom.mixed usage:

# #devtools::install_github("dustinfife/flexplot")
# library(flexplot)

Here it has some examples of code and output for saved logistic model fits

# # don't think flexplot will be super useful as we have so many categorical variables
# flexplot::logistic_fit
# flexplot::mixed_logistic
# flexplot::visualize(m_null)
# 
# # broom.mixed is used to tidy up the stats outputs into a tibble
# broom.mixed::tidy(m_null) # summary output in tibble
# broom.mixed::glance(m_null) # model performance summary

Random effects model

# n_randeffect <- glmer(trans_docs ~ 
#                         gender + age + I(age^2) + life_sat + religion + social_class + 
#                         (1|country),
#                data = complete_df,
#                family = "binomial",
#                control = glmerControl(optimizer = "bobyqa"),
#                nAGQ = 10)

This suggests the data needs to be rescaled, to check which variables are the issue:

# # check for nearzero variance, if so those could be removed
# nearZeroVar(complete_df, saveMetrics = TRUE)
# # see no issues. So all variables stay.
# 
# # will recode the numeric variables I selected, which is only age
# scaled_df <- complete_df |>
#   mutate(across(where(is.numeric), scale))

Re check the random effects model with scaled data:

# n_randeffect <- glmer(trans_docs ~
#                         gender + age + I(age^2) + life_sat + (1|country),
#                data = scaled_df,
#                family = "binomial",
#                control = glmerControl(optimizer = "bobyqa"),
#                nAGQ = 10)
# 
# 
# 
# summary(n_randeffect)

Can we interpret this…

Example Random effects models: m <- glmer(remission ~ IL6 + CRP + CancerStage + LengthofStay + Experience + (1 | DID), data = hdp, family = binomial, control = glmerControl(optimizer = “bobyqa”), nAGQ = 10)

Example from last year code glm_model_4 <- glmer(binary_qc19 ~ male + d11 + I(d11^2) + political_ideology + Religion_cat + sd1_7_factor + d60_ordinal + qc15_1_ordinal + prop_gndr_bin + prop_dis_wide + Unemployment + (1 | country_name), data = Data, family = binomial, control = glmerControl(optimizer = “bobyqa”, optCtrl = list(maxfun = 100000)))

Potentially useful package for visualising and interpreting linear mixed models: Flexplot -> https://github.com/dustinfife/flexplot Functions to quickly visualise LMM models and compare their performance.

broom.mixed The function broom.mixed::tidy() gives us all model parameters (random and fixed).

Useful calculations: - ICC (intra cluster correlation. How alike each of the observations within each group are) - ANOVA for model comparison: anova(null_model, lvl1_preds_model, lvl2_preds_model, rs_preds_model)